;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: CL-USER; Base: 10 -*-
;;; Regex test case testinput1 from PCRE.
;;;
;;; This file is automatically generated from PCRE's test data with
;;; Perl 5.008004 at 2004-05-24 17:44:50 UTC.
;;;
;;; See: http://www.pcre.org/ for PCRE, Perl Compatible Regex.
;;;
;

;;;; testinput1/2: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2"
  "the quick brown fox"
  "the quick brown fox"
  '(:single-line nil)
  (list "the quick brown fox") )

;;;; testinput1/3: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3"
  "the quick brown fox"
  "The quick brown FOX"
  '(:single-line nil)
  nil
 )

;;;; testinput1/4: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/4"
  "the quick brown fox"
  "What do you know about the quick brown fox?"
  '(:single-line nil)
  (list "the quick brown fox") )

;;;; testinput1/5: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/5"
  "the quick brown fox"
  "What do you know about THE QUICK BROWN FOX?"
  '(:single-line nil)
  nil
 )

;;;; testinput1/8: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/8"
  "The quick brown fox"
  "the quick brown fox"
  '(:ignore-case t :single-line nil)
  (list "the quick brown fox") )

;;;; testinput1/9: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/9"
  "The quick brown fox"
  "The quick brown FOX"
  '(:ignore-case t :single-line nil)
  (list "The quick brown FOX") )

;;;; testinput1/10: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/10"
  "The quick brown fox"
  "What do you know about the quick brown fox?"
  '(:ignore-case t :single-line nil)
  (list "the quick brown fox") )

;;;; testinput1/11: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/11"
  "The quick brown fox"
  "What do you know about THE QUICK BROWN FOX?"
  '(:ignore-case t :single-line nil)
  (list "THE QUICK BROWN FOX") )

;;;; testinput1/14: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/14"
  "abcd\\t\\n\\r\\f\\a\\e\\071\\x3b\\$\\\\\\?caxyz"
  (backslash "abcd\\t\\n\\u000D\\u000C\\u0007\\u001B9;$\\?caxyz")
  '(:single-line nil)
  (list (backslash "abcd\\t\\n\\u000D\\u000C\\u0007\\u001B9;$\\?caxyz")) )

;;;; testinput1/17: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/17"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/18: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/18"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/19: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/19"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/20: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/20"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/21: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/21"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/22: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/22"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/23: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/23"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aabcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aabcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/24: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/24"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypAzz") )

;;;; testinput1/25: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/25"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/26: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/26"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqAzz") )

;;;; testinput1/27: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/27"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqqAzz") )

;;;; testinput1/28: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/28"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqqqAzz") )

;;;; testinput1/29: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/29"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqqqqAzz") )

;;;; testinput1/30: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/30"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqqqqAzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypqqqqqqAzz") )

;;;; testinput1/31: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/31"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/32: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/32"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abxyzzpqrrrabbxyyyypqAzz") )

;;;; testinput1/33: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/33"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aabxyzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aabxyzzzpqrrrabbxyyyypqAzz") )

;;;; testinput1/34: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/34"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabxyzzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabxyzzzzpqrrrabbxyyyypqAzz") )

;;;; testinput1/35: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/35"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabxyzzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabxyzzzzpqrrrabbxyyyypqAzz") )

;;;; testinput1/36: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/36"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abcxyzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abcxyzzpqrrrabbxyyyypqAzz") )

;;;; testinput1/37: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/37"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aabcxyzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aabcxyzzzpqrrrabbxyyyypqAzz") )

;;;; testinput1/38: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/38"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabcxyzzzzpqrrrabbxyyyypqAzz") )

;;;; testinput1/39: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/39"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabcxyzzzzpqrrrabbxyyyypqAzz") )

;;;; testinput1/40: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/40"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabcxyzzzzpqrrrabbbxyyyypqAzz") )

;;;; testinput1/41: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/41"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbbxyyyyypqAzz"
  '(:single-line nil)
  (list "aaaabcxyzzzzpqrrrabbbxyyyyypqAzz") )

;;;; testinput1/42: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/42"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypABzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypABzz") )

;;;; testinput1/43: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/43"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypABBzz"
  '(:single-line nil)
  (list "aaabcxyzpqrrrabbxyyyypABBzz") )

;;;; testinput1/44: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/44"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  ">>>aaabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/45: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/45"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  ">aaaabxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "aaaabxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/46: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/46"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  ">>>>abcxyzpqrrrabbxyyyypqAzz"
  '(:single-line nil)
  (list "abcxyzpqrrrabbxyyyypqAzz") )

;;;; testinput1/47: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/47"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/48: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/48"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrabbxyyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/49: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/49"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrrrabbxyyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/50: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/50"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "abxyzpqrrrabxyyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/51: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/51"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbbxyyyyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/52: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/52"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaaabcxyzzzzpqrrrabbbxyyypqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/53: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/53"
  "a*abc?xyz+pqr{3}ab{2,}xy{4,5}pq{0,6}AB{0,}zz"
  "aaabcxyzpqrrrabbxyyyypqqqqqqqAzz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/56: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/56"
  "^(abc){1,2}zz"
  "abczz"
  '(:single-line nil)
  (list
    "abczz"
    "abc" ) )

;;;; testinput1/57: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/57"
  "^(abc){1,2}zz"
  "abcabczz"
  '(:single-line nil)
  (list
    "abcabczz"
    "abc" ) )

;;;; testinput1/58: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/58"
  "^(abc){1,2}zz"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/59: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/59"
  "^(abc){1,2}zz"
  "zz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/60: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/60"
  "^(abc){1,2}zz"
  "abcabcabczz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/61: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/61"
  "^(abc){1,2}zz"
  ">>abczz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/64: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/64"
  "^(b+?|a){1,2}?c"
  "bc"
  '(:single-line nil)
  (list
    "bc"
    "b" ) )

;;;; testinput1/65: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/65"
  "^(b+?|a){1,2}?c"
  "bbc"
  '(:single-line nil)
  (list
    "bbc"
    "b" ) )

;;;; testinput1/66: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/66"
  "^(b+?|a){1,2}?c"
  "bbbc"
  '(:single-line nil)
  (list
    "bbbc"
    "bb" ) )

;;;; testinput1/67: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/67"
  "^(b+?|a){1,2}?c"
  "bac"
  '(:single-line nil)
  (list
    "bac"
    "a" ) )

;;;; testinput1/68: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/68"
  "^(b+?|a){1,2}?c"
  "bbac"
  '(:single-line nil)
  (list
    "bbac"
    "a" ) )

;;;; testinput1/69: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/69"
  "^(b+?|a){1,2}?c"
  "aac"
  '(:single-line nil)
  (list
    "aac"
    "a" ) )

;;;; testinput1/70: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/70"
  "^(b+?|a){1,2}?c"
  "abbbbbbbbbbbc"
  '(:single-line nil)
  (list
    "abbbbbbbbbbbc"
    "bbbbbbbbbbb" ) )

;;;; testinput1/71: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/71"
  "^(b+?|a){1,2}?c"
  "bbbbbbbbbbbac"
  '(:single-line nil)
  (list
    "bbbbbbbbbbbac"
    "a" ) )

;;;; testinput1/72: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/72"
  "^(b+?|a){1,2}?c"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/73: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/73"
  "^(b+?|a){1,2}?c"
  "aaac"
  '(:single-line nil)
  nil
 )

;;;; testinput1/74: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/74"
  "^(b+?|a){1,2}?c"
  "abbbbbbbbbbbac"
  '(:single-line nil)
  nil
 )

;;;; testinput1/77: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/77"
  "^(b+|a){1,2}c"
  "bc"
  '(:single-line nil)
  (list
    "bc"
    "b" ) )

;;;; testinput1/78: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/78"
  "^(b+|a){1,2}c"
  "bbc"
  '(:single-line nil)
  (list
    "bbc"
    "bb" ) )

;;;; testinput1/79: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/79"
  "^(b+|a){1,2}c"
  "bbbc"
  '(:single-line nil)
  (list
    "bbbc"
    "bbb" ) )

;;;; testinput1/80: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/80"
  "^(b+|a){1,2}c"
  "bac"
  '(:single-line nil)
  (list
    "bac"
    "a" ) )

;;;; testinput1/81: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/81"
  "^(b+|a){1,2}c"
  "bbac"
  '(:single-line nil)
  (list
    "bbac"
    "a" ) )

;;;; testinput1/82: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/82"
  "^(b+|a){1,2}c"
  "aac"
  '(:single-line nil)
  (list
    "aac"
    "a" ) )

;;;; testinput1/83: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/83"
  "^(b+|a){1,2}c"
  "abbbbbbbbbbbc"
  '(:single-line nil)
  (list
    "abbbbbbbbbbbc"
    "bbbbbbbbbbb" ) )

;;;; testinput1/84: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/84"
  "^(b+|a){1,2}c"
  "bbbbbbbbbbbac"
  '(:single-line nil)
  (list
    "bbbbbbbbbbbac"
    "a" ) )

;;;; testinput1/85: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/85"
  "^(b+|a){1,2}c"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/86: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/86"
  "^(b+|a){1,2}c"
  "aaac"
  '(:single-line nil)
  nil
 )

;;;; testinput1/87: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/87"
  "^(b+|a){1,2}c"
  "abbbbbbbbbbbac"
  '(:single-line nil)
  nil
 )

;;;; testinput1/90: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/90"
  "^(b+|a){1,2}?bc"
  "bbc"
  '(:single-line nil)
  (list
    "bbc"
    "b" ) )

;;;; testinput1/93: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/93"
  "^(b*|ba){1,2}?bc"
  "babc"
  '(:single-line nil)
  (list
    "babc"
    "ba" ) )

;;;; testinput1/94: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/94"
  "^(b*|ba){1,2}?bc"
  "bbabc"
  '(:single-line nil)
  (list
    "bbabc"
    "ba" ) )

;;;; testinput1/95: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/95"
  "^(b*|ba){1,2}?bc"
  "bababc"
  '(:single-line nil)
  (list
    "bababc"
    "ba" ) )

;;;; testinput1/96: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/96"
  "^(b*|ba){1,2}?bc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/97: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/97"
  "^(b*|ba){1,2}?bc"
  "bababbc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/98: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/98"
  "^(b*|ba){1,2}?bc"
  "babababc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/101: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/101"
  "^(ba|b*){1,2}?bc"
  "babc"
  '(:single-line nil)
  (list
    "babc"
    "ba" ) )

;;;; testinput1/102: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/102"
  "^(ba|b*){1,2}?bc"
  "bbabc"
  '(:single-line nil)
  (list
    "bbabc"
    "ba" ) )

;;;; testinput1/103: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/103"
  "^(ba|b*){1,2}?bc"
  "bababc"
  '(:single-line nil)
  (list
    "bababc"
    "ba" ) )

;;;; testinput1/104: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/104"
  "^(ba|b*){1,2}?bc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/105: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/105"
  "^(ba|b*){1,2}?bc"
  "bababbc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/106: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/106"
  "^(ba|b*){1,2}?bc"
  "babababc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/109: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/109"
  "^\\ca\\cA\\c[\\c{\\c:"
  (backslash "\\u0001\\u0001\\u001B;z")
  '(:single-line nil)
  (list (backslash "\\u0001\\u0001\\u001B;z")) )

;;;; testinput1/112: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/112"
  "^[ab\\]cde]"
  "athing"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/113: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/113"
  "^[ab\\]cde]"
  "bthing"
  '(:single-line nil)
  (list "b") )

;;;; testinput1/114: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/114"
  "^[ab\\]cde]"
  "]thing"
  '(:single-line nil)
  (list "]") )

;;;; testinput1/115: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/115"
  "^[ab\\]cde]"
  "cthing"
  '(:single-line nil)
  (list "c") )

;;;; testinput1/116: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/116"
  "^[ab\\]cde]"
  "dthing"
  '(:single-line nil)
  (list "d") )

;;;; testinput1/117: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/117"
  "^[ab\\]cde]"
  "ething"
  '(:single-line nil)
  (list "e") )

;;;; testinput1/118: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/118"
  "^[ab\\]cde]"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/119: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/119"
  "^[ab\\]cde]"
  "fthing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/120: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/120"
  "^[ab\\]cde]"
  "[thing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/121: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/121"
  "^[ab\\]cde]"
  "\\thing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/124: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/124"
  "^[]cde]"
  "]thing"
  '(:single-line nil)
  (list "]") )

;;;; testinput1/125: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/125"
  "^[]cde]"
  "cthing"
  '(:single-line nil)
  (list "c") )

;;;; testinput1/126: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/126"
  "^[]cde]"
  "dthing"
  '(:single-line nil)
  (list "d") )

;;;; testinput1/127: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/127"
  "^[]cde]"
  "ething"
  '(:single-line nil)
  (list "e") )

;;;; testinput1/128: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/128"
  "^[]cde]"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/129: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/129"
  "^[]cde]"
  "athing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/130: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/130"
  "^[]cde]"
  "fthing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/133: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/133"
  "^[^ab\\]cde]"
  "fthing"
  '(:single-line nil)
  (list "f") )

;;;; testinput1/134: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/134"
  "^[^ab\\]cde]"
  "[thing"
  '(:single-line nil)
  (list "[") )

;;;; testinput1/135: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/135"
  "^[^ab\\]cde]"
  "\\thing"
  '(:single-line nil)
  (list "\\") )

;;;; testinput1/136: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/136"
  "^[^ab\\]cde]"
  "*** Failers"
  '(:single-line nil)
  (list "*") )

;;;; testinput1/137: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/137"
  "^[^ab\\]cde]"
  "athing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/138: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/138"
  "^[^ab\\]cde]"
  "bthing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/139: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/139"
  "^[^ab\\]cde]"
  "]thing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/140: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/140"
  "^[^ab\\]cde]"
  "cthing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/141: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/141"
  "^[^ab\\]cde]"
  "dthing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/142: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/142"
  "^[^ab\\]cde]"
  "ething"
  '(:single-line nil)
  nil
 )

;;;; testinput1/145: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/145"
  "^[^]cde]"
  "athing"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/146: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/146"
  "^[^]cde]"
  "fthing"
  '(:single-line nil)
  (list "f") )

;;;; testinput1/147: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/147"
  "^[^]cde]"
  "*** Failers"
  '(:single-line nil)
  (list "*") )

;;;; testinput1/148: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/148"
  "^[^]cde]"
  "]thing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/149: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/149"
  "^[^]cde]"
  "cthing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/150: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/150"
  "^[^]cde]"
  "dthing"
  '(:single-line nil)
  nil
 )

;;;; testinput1/151: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/151"
  "^[^]cde]"
  "ething"
  '(:single-line nil)
  nil
 )

;;;; testinput1/154: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/154"
  (backslash "^\\\\u0081")
  (backslash "\\u0081")
  '(:single-line nil)
  (list (backslash "\\u0081")) )

;;;; testinput1/157: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/157"
  (backslash "^\\u00FF")
  (backslash "\\u00FF")
  '(:single-line nil)
  (list (backslash "\\u00FF")) )

;;;; testinput1/160: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/160"
  "^[0-9]+$"
  "0"
  '(:single-line nil)
  (list "0") )

;;;; testinput1/161: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/161"
  "^[0-9]+$"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; testinput1/162: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/162"
  "^[0-9]+$"
  "2"
  '(:single-line nil)
  (list "2") )

;;;; testinput1/163: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/163"
  "^[0-9]+$"
  "3"
  '(:single-line nil)
  (list "3") )

;;;; testinput1/164: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/164"
  "^[0-9]+$"
  "4"
  '(:single-line nil)
  (list "4") )

;;;; testinput1/165: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/165"
  "^[0-9]+$"
  "5"
  '(:single-line nil)
  (list "5") )

;;;; testinput1/166: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/166"
  "^[0-9]+$"
  "6"
  '(:single-line nil)
  (list "6") )

;;;; testinput1/167: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/167"
  "^[0-9]+$"
  "7"
  '(:single-line nil)
  (list "7") )

;;;; testinput1/168: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/168"
  "^[0-9]+$"
  "8"
  '(:single-line nil)
  (list "8") )

;;;; testinput1/169: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/169"
  "^[0-9]+$"
  "9"
  '(:single-line nil)
  (list "9") )

;;;; testinput1/170: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/170"
  "^[0-9]+$"
  "10"
  '(:single-line nil)
  (list "10") )

;;;; testinput1/171: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/171"
  "^[0-9]+$"
  "100"
  '(:single-line nil)
  (list "100") )

;;;; testinput1/172: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/172"
  "^[0-9]+$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/173: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/173"
  "^[0-9]+$"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/176: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/176"
  "^.*nter"
  "enter"
  '(:single-line nil)
  (list "enter") )

;;;; testinput1/177: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/177"
  "^.*nter"
  "inter"
  '(:single-line nil)
  (list "inter") )

;;;; testinput1/178: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/178"
  "^.*nter"
  "uponter"
  '(:single-line nil)
  (list "uponter") )

;;;; testinput1/181: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/181"
  "^xxx[0-9]+$"
  "xxx0"
  '(:single-line nil)
  (list "xxx0") )

;;;; testinput1/182: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/182"
  "^xxx[0-9]+$"
  "xxx1234"
  '(:single-line nil)
  (list "xxx1234") )

;;;; testinput1/183: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/183"
  "^xxx[0-9]+$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/184: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/184"
  "^xxx[0-9]+$"
  "xxx"
  '(:single-line nil)
  nil
 )

;;;; testinput1/187: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/187"
  "^.+[0-9][0-9][0-9]$"
  "x123"
  '(:single-line nil)
  (list "x123") )

;;;; testinput1/188: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/188"
  "^.+[0-9][0-9][0-9]$"
  "xx123"
  '(:single-line nil)
  (list "xx123") )

;;;; testinput1/189: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/189"
  "^.+[0-9][0-9][0-9]$"
  "123456"
  '(:single-line nil)
  (list "123456") )

;;;; testinput1/190: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/190"
  "^.+[0-9][0-9][0-9]$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/191: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/191"
  "^.+[0-9][0-9][0-9]$"
  "123"
  '(:single-line nil)
  nil
 )

;;;; testinput1/192: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/192"
  "^.+[0-9][0-9][0-9]$"
  "x1234"
  '(:single-line nil)
  (list "x1234") )

;;;; testinput1/195: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/195"
  "^.+?[0-9][0-9][0-9]$"
  "x123"
  '(:single-line nil)
  (list "x123") )

;;;; testinput1/196: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/196"
  "^.+?[0-9][0-9][0-9]$"
  "xx123"
  '(:single-line nil)
  (list "xx123") )

;;;; testinput1/197: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/197"
  "^.+?[0-9][0-9][0-9]$"
  "123456"
  '(:single-line nil)
  (list "123456") )

;;;; testinput1/198: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/198"
  "^.+?[0-9][0-9][0-9]$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/199: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/199"
  "^.+?[0-9][0-9][0-9]$"
  "123"
  '(:single-line nil)
  nil
 )

;;;; testinput1/200: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/200"
  "^.+?[0-9][0-9][0-9]$"
  "x1234"
  '(:single-line nil)
  (list "x1234") )

;;;; testinput1/203: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/203"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "abc!pqr=apquxz.ixr.zzz.ac.uk"
  '(:single-line nil)
  (list
    "abc!pqr=apquxz.ixr.zzz.ac.uk"
    "abc"
    "pqr" ) )

;;;; testinput1/204: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/204"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/205: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/205"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "!pqr=apquxz.ixr.zzz.ac.uk"
  '(:single-line nil)
  nil
 )

;;;; testinput1/206: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/206"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "abc!=apquxz.ixr.zzz.ac.uk"
  '(:single-line nil)
  nil
 )

;;;; testinput1/207: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/207"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "abc!pqr=apquxz:ixr.zzz.ac.uk"
  '(:single-line nil)
  nil
 )

;;;; testinput1/208: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/208"
  "^([^!]+)!(.+)=apquxz\\.ixr\\.zzz\\.ac\\.uk$"
  "abc!pqr=apquxz.ixr.zzz.ac.ukk"
  '(:single-line nil)
  nil
 )

;;;; testinput1/211: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/211"
  ":"
  "Well, we need a colon: somewhere"
  '(:single-line nil)
  (list ":") )

;;;; testinput1/212: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/212"
  ":"
  "*** Fail if we don't"
  '(:single-line nil)
  nil
 )

;;;; testinput1/215: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/215"
  "([\\da-f:]+)$"
  "0abc"
  '(:ignore-case t :single-line nil)
  (list
    "0abc"
    "0abc" ) )

;;;; testinput1/216: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/216"
  "([\\da-f:]+)$"
  "abc"
  '(:ignore-case t :single-line nil)
  (list
    "abc"
    "abc" ) )

;;;; testinput1/217: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/217"
  "([\\da-f:]+)$"
  "fed"
  '(:ignore-case t :single-line nil)
  (list
    "fed"
    "fed" ) )

;;;; testinput1/218: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/218"
  "([\\da-f:]+)$"
  "E"
  '(:ignore-case t :single-line nil)
  (list
    "E"
    "E" ) )

;;;; testinput1/219: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/219"
  "([\\da-f:]+)$"
  "::"
  '(:ignore-case t :single-line nil)
  (list
    "::"
    "::" ) )

;;;; testinput1/220: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/220"
  "([\\da-f:]+)$"
  "5f03:12C0::932e"
  '(:ignore-case t :single-line nil)
  (list
    "5f03:12C0::932e"
    "5f03:12C0::932e" ) )

;;;; testinput1/221: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/221"
  "([\\da-f:]+)$"
  "fed def"
  '(:ignore-case t :single-line nil)
  (list
    "def"
    "def" ) )

;;;; testinput1/222: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/222"
  "([\\da-f:]+)$"
  "Any old stuff"
  '(:ignore-case t :single-line nil)
  (list
    "ff"
    "ff" ) )

;;;; testinput1/223: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/223"
  "([\\da-f:]+)$"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/224: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/224"
  "([\\da-f:]+)$"
  "0zzz"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/225: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/225"
  "([\\da-f:]+)$"
  "gzzz"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/226: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/226"
  "([\\da-f:]+)$"
  "fed "
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/227: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/227"
  "([\\da-f:]+)$"
  "Any old rubbish"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/230: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/230"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  ".1.2.3"
  '(:single-line nil)
  (list
    ".1.2.3"
    "1"
    "2"
    "3" ) )

;;;; testinput1/231: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/231"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  "A.12.123.0"
  '(:single-line nil)
  (list
    "A.12.123.0"
    "12"
    "123"
    "0" ) )

;;;; testinput1/232: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/232"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/233: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/233"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  ".1.2.3333"
  '(:single-line nil)
  nil
 )

;;;; testinput1/234: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/234"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  "1.2.3"
  '(:single-line nil)
  nil
 )

;;;; testinput1/235: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/235"
  "^.*\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$"
  "1234.2.3"
  '(:single-line nil)
  nil
 )

;;;; testinput1/238: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/238"
  "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$"
  "1 IN SOA non-sp1 non-sp2("
  '(:single-line nil)
  (list
    "1 IN SOA non-sp1 non-sp2("
    "1"
    "non-sp1"
    "non-sp2" ) )

;;;; testinput1/239: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/239"
  "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$"
  "1    IN    SOA    non-sp1    non-sp2   ("
  '(:single-line nil)
  (list
    "1    IN    SOA    non-sp1    non-sp2   ("
    "1"
    "non-sp1"
    "non-sp2" ) )

;;;; testinput1/240: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/240"
  "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/241: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/241"
  "^(\\d+)\\s+IN\\s+SOA\\s+(\\S+)\\s+(\\S+)\\s*\\(\\s*$"
  "1IN SOA non-sp1 non-sp2("
  '(:single-line nil)
  nil
 )

;;;; testinput1/244: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/244"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "a."
  '(:single-line nil)
  (list "a.") )

;;;; testinput1/245: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/245"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "Z."
  '(:single-line nil)
  (list "Z.") )

;;;; testinput1/246: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/246"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "2."
  '(:single-line nil)
  (list "2.") )

;;;; testinput1/247: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/247"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "ab-c.pq-r."
  '(:single-line nil)
  (list
    "ab-c.pq-r."
    ".pq-r" ) )

;;;; testinput1/248: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/248"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "sxk.zzz.ac.uk."
  '(:single-line nil)
  (list
    "sxk.zzz.ac.uk."
    ".uk" ) )

;;;; testinput1/249: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/249"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "x-.y-."
  '(:single-line nil)
  (list
    "x-.y-."
    ".y-" ) )

;;;; testinput1/250: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/250"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/251: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/251"
  "^[a-zA-Z\\d][a-zA-Z\\d\\-]*(\\.[a-zA-Z\\d][a-zA-z\\d\\-]*)*\\.$"
  "-abc.peq."
  '(:single-line nil)
  nil
 )

;;;; testinput1/254: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/254"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.a"
  '(:single-line nil)
  (list "*.a") )

;;;; testinput1/255: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/255"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.b0-a"
  '(:single-line nil)
  (list
    "*.b0-a"
    "0-a" ) )

;;;; testinput1/256: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/256"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.c3-b.c"
  '(:single-line nil)
  (list
    "*.c3-b.c"
    "3-b"
    ".c" ) )

;;;; testinput1/257: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/257"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.c-a.b-c"
  '(:single-line nil)
  (list
    "*.c-a.b-c"
    "-a"
    ".b-c"
    "-c" ) )

;;;; testinput1/258: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/258"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/259: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/259"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.0"
  '(:single-line nil)
  nil
 )

;;;; testinput1/260: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/260"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.a-"
  '(:single-line nil)
  nil
 )

;;;; testinput1/261: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/261"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.a-b.c-"
  '(:single-line nil)
  nil
 )

;;;; testinput1/262: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/262"
  "^\\*\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?(\\.[a-z]([a-z\\-\\d]*[a-z\\d]+)?)*$"
  "*.c-a.0-c"
  '(:single-line nil)
  nil
 )

;;;; testinput1/265: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/265"
  "^(?=ab(de))(abd)(e)"
  "abde"
  '(:single-line nil)
  (list
    "abde"
    "de"
    "abd"
    "e" ) )

;;;; testinput1/268: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/268"
  "^(?!(ab)de|x)(abd)(f)"
  "abdf"
  '(:single-line nil)
  (list
    "abdf"
    nil
    "abd"
    "f" ) )

;;;; testinput1/271: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/271"
  "^(?=(ab(cd)))(ab)"
  "abcd"
  '(:single-line nil)
  (list
    "ab"
    "abcd"
    "cd"
    "ab" ) )

;;;; testinput1/274: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/274"
  "^[\\da-f](\\.[\\da-f])*$"
  "a.b.c.d"
  '(:ignore-case t :single-line nil)
  (list
    "a.b.c.d"
    ".d" ) )

;;;; testinput1/275: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/275"
  "^[\\da-f](\\.[\\da-f])*$"
  "A.B.C.D"
  '(:ignore-case t :single-line nil)
  (list
    "A.B.C.D"
    ".D" ) )

;;;; testinput1/276: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/276"
  "^[\\da-f](\\.[\\da-f])*$"
  "a.b.c.1.2.3.C"
  '(:ignore-case t :single-line nil)
  (list
    "a.b.c.1.2.3.C"
    ".C" ) )

;;;; testinput1/279: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/279"
  "^\".*\"\\s*(;.*)?$"
  "\"1234\""
  '(:single-line nil)
  (list "\"1234\"") )

;;;; testinput1/280: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/280"
  "^\".*\"\\s*(;.*)?$"
  "\"abcd\" ;"
  '(:single-line nil)
  (list
    "\"abcd\" ;"
    ";" ) )

;;;; testinput1/281: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/281"
  "^\".*\"\\s*(;.*)?$"
  "\"\" ; rhubarb"
  '(:single-line nil)
  (list
    "\"\" ; rhubarb"
    "; rhubarb" ) )

;;;; testinput1/282: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/282"
  "^\".*\"\\s*(;.*)?$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/283: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/283"
  "^\".*\"\\s*(;.*)?$"
  "\"1234\" : things"
  '(:single-line nil)
  nil
 )

;;;; testinput1/286: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/286"
  "^$"
  ""
  '(:single-line nil)
  (list "") )

;;;; testinput1/287: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/287"
  "^$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/290: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/290"
  "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "ab c"
  '(:extended-syntax t :single-line nil)
  (list "ab c") )

;;;; testinput1/291: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/291"
  "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "*** Failers"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/292: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/292"
  "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "abc"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/293: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/293"
  "   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "ab cde"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/296: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/296"
  "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "ab c"
  '(:single-line nil)
  (list "ab c") )

;;;; testinput1/297: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/297"
  "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/298: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/298"
  "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/299: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/299"
  "(?x)   ^    a   (?# begins with a)  b\\sc (?# then b c) $ (?# then end)"
  "ab cde"
  '(:single-line nil)
  nil
 )

;;;; testinput1/302: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/302"
  "^   a\\ b[c ]d       $"
  "a bcd"
  '(:extended-syntax t :single-line nil)
  (list "a bcd") )

;;;; testinput1/303: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/303"
  "^   a\\ b[c ]d       $"
  "a b d"
  '(:extended-syntax t :single-line nil)
  (list "a b d") )

;;;; testinput1/304: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/304"
  "^   a\\ b[c ]d       $"
  "*** Failers"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/305: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/305"
  "^   a\\ b[c ]d       $"
  "abcd"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/306: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/306"
  "^   a\\ b[c ]d       $"
  "ab d"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/309: 
;;;
;;;    Matched with 12 captures.
;
(test-case
  "pcre-1/309"
  "^(a(b(c)))(d(e(f)))(h(i(j)))(k(l(m)))$"
  "abcdefhijklm"
  '(:single-line nil)
  (list
    "abcdefhijklm"
    "abc"
    "bc"
    "c"
    "def"
    "ef"
    "f"
    "hij"
    "ij"
    "j"
    "klm"
    "lm"
    "m" ) )

;;;; testinput1/312: 
;;;
;;;    Matched with 8 captures.
;
(test-case
  "pcre-1/312"
  "^(?:a(b(c)))(?:d(e(f)))(?:h(i(j)))(?:k(l(m)))$"
  "abcdefhijklm"
  '(:single-line nil)
  (list
    "abcdefhijklm"
    "bc"
    "c"
    "ef"
    "f"
    "ij"
    "j"
    "lm"
    "m" ) )

;;;; testinput1/315: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/315"
  "^[\\w][\\W][\\s][\\S][\\d][\\D][\\b][\\n][\\c]][\\022]"
  (backslash "a+ Z0+\\u0008\\n\\u001D\\u0012")
  '(:single-line nil)
  (list (backslash "a+ Z0+\\u0008\\n\\u001D\\u0012")) )

;;;; testinput1/318: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/318"
  "^[.^$|()*+?{,}]+"
  ".^$(*+)|{?,?}"
  '(:single-line nil)
  (list ".^$(*+)|{?,?}") )

;;;; testinput1/321: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/321"
  "^a*\\w"
  "z"
  '(:single-line nil)
  (list "z") )

;;;; testinput1/322: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/322"
  "^a*\\w"
  "az"
  '(:single-line nil)
  (list "az") )

;;;; testinput1/323: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/323"
  "^a*\\w"
  "aaaz"
  '(:single-line nil)
  (list "aaaz") )

;;;; testinput1/324: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/324"
  "^a*\\w"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/325: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/325"
  "^a*\\w"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput1/326: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/326"
  "^a*\\w"
  "aaaa"
  '(:single-line nil)
  (list "aaaa") )

;;;; testinput1/327: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/327"
  "^a*\\w"
  "a+"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/328: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/328"
  "^a*\\w"
  "aa+"
  '(:single-line nil)
  (list "aa") )

;;;; testinput1/331: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/331"
  "^a*?\\w"
  "z"
  '(:single-line nil)
  (list "z") )

;;;; testinput1/332: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/332"
  "^a*?\\w"
  "az"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/333: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/333"
  "^a*?\\w"
  "aaaz"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/334: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/334"
  "^a*?\\w"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/335: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/335"
  "^a*?\\w"
  "aa"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/336: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/336"
  "^a*?\\w"
  "aaaa"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/337: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/337"
  "^a*?\\w"
  "a+"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/338: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/338"
  "^a*?\\w"
  "aa+"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/341: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/341"
  "^a+\\w"
  "az"
  '(:single-line nil)
  (list "az") )

;;;; testinput1/342: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/342"
  "^a+\\w"
  "aaaz"
  '(:single-line nil)
  (list "aaaz") )

;;;; testinput1/343: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/343"
  "^a+\\w"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput1/344: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/344"
  "^a+\\w"
  "aaaa"
  '(:single-line nil)
  (list "aaaa") )

;;;; testinput1/345: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/345"
  "^a+\\w"
  "aa+"
  '(:single-line nil)
  (list "aa") )

;;;; testinput1/348: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/348"
  "^a+?\\w"
  "az"
  '(:single-line nil)
  (list "az") )

;;;; testinput1/349: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/349"
  "^a+?\\w"
  "aaaz"
  '(:single-line nil)
  (list "aa") )

;;;; testinput1/350: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/350"
  "^a+?\\w"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput1/351: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/351"
  "^a+?\\w"
  "aaaa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput1/352: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/352"
  "^a+?\\w"
  "aa+"
  '(:single-line nil)
  (list "aa") )

;;;; testinput1/355: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/355"
  "^\\d{8}\\w{2,}"
  "1234567890"
  '(:single-line nil)
  (list "1234567890") )

;;;; testinput1/356: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/356"
  "^\\d{8}\\w{2,}"
  "12345678ab"
  '(:single-line nil)
  (list "12345678ab") )

;;;; testinput1/357: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/357"
  "^\\d{8}\\w{2,}"
  "12345678__"
  '(:single-line nil)
  (list "12345678__") )

;;;; testinput1/358: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/358"
  "^\\d{8}\\w{2,}"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/359: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/359"
  "^\\d{8}\\w{2,}"
  "1234567"
  '(:single-line nil)
  nil
 )

;;;; testinput1/362: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/362"
  "^[aeiou\\d]{4,5}$"
  "uoie"
  '(:single-line nil)
  (list "uoie") )

;;;; testinput1/363: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/363"
  "^[aeiou\\d]{4,5}$"
  "1234"
  '(:single-line nil)
  (list "1234") )

;;;; testinput1/364: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/364"
  "^[aeiou\\d]{4,5}$"
  "12345"
  '(:single-line nil)
  (list "12345") )

;;;; testinput1/365: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/365"
  "^[aeiou\\d]{4,5}$"
  "aaaaa"
  '(:single-line nil)
  (list "aaaaa") )

;;;; testinput1/366: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/366"
  "^[aeiou\\d]{4,5}$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/367: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/367"
  "^[aeiou\\d]{4,5}$"
  "123456"
  '(:single-line nil)
  nil
 )

;;;; testinput1/370: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/370"
  "^[aeiou\\d]{4,5}?"
  "uoie"
  '(:single-line nil)
  (list "uoie") )

;;;; testinput1/371: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/371"
  "^[aeiou\\d]{4,5}?"
  "1234"
  '(:single-line nil)
  (list "1234") )

;;;; testinput1/372: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/372"
  "^[aeiou\\d]{4,5}?"
  "12345"
  '(:single-line nil)
  (list "1234") )

;;;; testinput1/373: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/373"
  "^[aeiou\\d]{4,5}?"
  "aaaaa"
  '(:single-line nil)
  (list "aaaa") )

;;;; testinput1/374: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/374"
  "^[aeiou\\d]{4,5}?"
  "123456"
  '(:single-line nil)
  (list "1234") )

;;;; testinput1/377: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/377"
  "\\A(abc|def)=(\\1){2,3}\\Z"
  "abc=abcabc"
  '(:single-line nil)
  (list
    "abc=abcabc"
    "abc"
    "abc" ) )

;;;; testinput1/378: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/378"
  "\\A(abc|def)=(\\1){2,3}\\Z"
  "def=defdefdef"
  '(:single-line nil)
  (list
    "def=defdefdef"
    "def"
    "def" ) )

;;;; testinput1/379: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/379"
  "\\A(abc|def)=(\\1){2,3}\\Z"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/380: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/380"
  "\\A(abc|def)=(\\1){2,3}\\Z"
  "abc=defdef"
  '(:single-line nil)
  nil
 )

;;;; testinput1/383: 
;;;
;;;    Matched with 12 captures.
;
(test-case
  "pcre-1/383"
  "^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11*(\\3\\4)\\1(?#)2$"
  "abcdefghijkcda2"
  '(:single-line nil)
  (list
    "abcdefghijkcda2"
    "a"
    "b"
    "c"
    "d"
    "e"
    "f"
    "g"
    "h"
    "i"
    "j"
    "k"
    "cd" ) )

;;;; testinput1/384: 
;;;
;;;    Matched with 12 captures.
;
(test-case
  "pcre-1/384"
  "^(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11*(\\3\\4)\\1(?#)2$"
  "abcdefghijkkkkcda2"
  '(:single-line nil)
  (list
    "abcdefghijkkkkcda2"
    "a"
    "b"
    "c"
    "d"
    "e"
    "f"
    "g"
    "h"
    "i"
    "j"
    "k"
    "cd" ) )

;;;; testinput1/387: 
;;;
;;;    Matched with 5 captures.
;
(test-case
  "pcre-1/387"
  "(cat(a(ract|tonic)|erpillar)) \\1()2(3)"
  "cataract cataract23"
  '(:single-line nil)
  (list
    "cataract cataract23"
    "cataract"
    "aract"
    "ract"
    ""
    "3" ) )

;;;; testinput1/388: 
;;;
;;;    Matched with 5 captures.
;
(test-case
  "pcre-1/388"
  "(cat(a(ract|tonic)|erpillar)) \\1()2(3)"
  "catatonic catatonic23"
  '(:single-line nil)
  (list
    "catatonic catatonic23"
    "catatonic"
    "atonic"
    "tonic"
    ""
    "3" ) )

;;;; testinput1/389: 
;;;
;;;    Matched with 5 captures.
;
(test-case
  "pcre-1/389"
  "(cat(a(ract|tonic)|erpillar)) \\1()2(3)"
  "caterpillar caterpillar23"
  '(:single-line nil)
  (list
    "caterpillar caterpillar23"
    "caterpillar"
    "erpillar"
    nil
    ""
    "3" ) )

;;;; testinput1/393: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/393"
  "^From +([^ ]+) +[a-zA-Z][a-zA-Z][a-zA-Z] +[a-zA-Z][a-zA-Z][a-zA-Z] +[0-9]?[0-9] +[0-9][0-9]:[0-9][0-9]"
  "From abcd  Mon Sep 01 12:33:02 1997"
  '(:single-line nil)
  (list
    "From abcd  Mon Sep 01 12:33"
    "abcd" ) )

;;;; testinput1/396: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/396"
  "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d"
  "From abcd  Mon Sep 01 12:33:02 1997"
  '(:single-line nil)
  (list
    "From abcd  Mon Sep 01 12:33"
    "Sep " ) )

;;;; testinput1/397: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/397"
  "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d"
  "From abcd  Mon Sep  1 12:33:02 1997"
  '(:single-line nil)
  (list
    "From abcd  Mon Sep  1 12:33"
    "Sep  " ) )

;;;; testinput1/398: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/398"
  "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/399: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/399"
  "^From\\s+\\S+\\s+([a-zA-Z]{3}\\s+){2}\\d{1,2}\\s+\\d\\d:\\d\\d"
  "From abcd  Sep 01 12:33:02 1997"
  '(:single-line nil)
  nil
 )

;;;; testinput1/402: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/402"
  "^12.34"
  (backslash "12\\n34")
  '(:single-line t)
  (list (backslash "12\\n34")) )

;;;; testinput1/403: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/403"
  "^12.34"
  (backslash "12\\u000D34")
  '(:single-line t)
  (list (backslash "12\\u000D34")) )

;;;; testinput1/406: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/406"
  "\\w+(?=\\t)"
  (backslash "the quick brown\\t fox")
  '(:single-line nil)
  (list "brown") )

;;;; testinput1/409: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/409"
  "foo(?!bar)(.*)"
  "foobar is foolish see?"
  '(:single-line nil)
  (list
    "foolish see?"
    "lish see?" ) )

;;;; testinput1/412: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/412"
  "(?:(?!foo)...|^.{0,2})bar(.*)"
  "foobar crowbar etc"
  '(:single-line nil)
  (list
    "rowbar etc"
    " etc" ) )

;;;; testinput1/413: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/413"
  "(?:(?!foo)...|^.{0,2})bar(.*)"
  "barrel"
  '(:single-line nil)
  (list
    "barrel"
    "rel" ) )

;;;; testinput1/414: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/414"
  "(?:(?!foo)...|^.{0,2})bar(.*)"
  "2barrel"
  '(:single-line nil)
  (list
    "2barrel"
    "rel" ) )

;;;; testinput1/415: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/415"
  "(?:(?!foo)...|^.{0,2})bar(.*)"
  "A barrel"
  '(:single-line nil)
  (list
    "A barrel"
    "rel" ) )

;;;; testinput1/418: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/418"
  "^(\\D*)(?=\\d)(?!123)"
  "abc456"
  '(:single-line nil)
  (list
    "abc"
    "abc" ) )

;;;; testinput1/419: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/419"
  "^(\\D*)(?=\\d)(?!123)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/420: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/420"
  "^(\\D*)(?=\\d)(?!123)"
  "abc123"
  '(:single-line nil)
  nil
 )

;;;; testinput1/424: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/424"
  (backslash "^1234(?# test newlines\\n  inside)")
  "1234"
  '(:single-line nil)
  (list "1234") )

;;;; testinput1/428: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/428"
  (backslash "^1234 #comment in extended re\\n  ")
  "1234"
  '(:extended-syntax t :single-line nil)
  (list "1234") )

;;;; testinput1/432: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/432"
  (backslash "#rhubarb\\n  abcd")
  "abcd"
  '(:extended-syntax t :single-line nil)
  (list "abcd") )

;;;; testinput1/435: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/435"
  "^abcd#rhubarb"
  "abcd"
  '(:extended-syntax t :single-line nil)
  (list "abcd") )

;;;; testinput1/438: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/438"
  "^(a)\\1{2,3}(.)"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "a"
    "b" ) )

;;;; testinput1/439: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/439"
  "^(a)\\1{2,3}(.)"
  "aaaab"
  '(:single-line nil)
  (list
    "aaaab"
    "a"
    "b" ) )

;;;; testinput1/440: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/440"
  "^(a)\\1{2,3}(.)"
  "aaaaab"
  '(:single-line nil)
  (list
    "aaaaa"
    "a"
    "a" ) )

;;;; testinput1/441: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/441"
  "^(a)\\1{2,3}(.)"
  "aaaaaab"
  '(:single-line nil)
  (list
    "aaaaa"
    "a"
    "a" ) )

;;;; testinput1/444: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/444"
  "(?!^)abc"
  "the abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/445: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/445"
  "(?!^)abc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/446: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/446"
  "(?!^)abc"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/449: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/449"
  "(?=^)abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/450: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/450"
  "(?=^)abc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/451: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/451"
  "(?=^)abc"
  "the abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/454: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/454"
  "^[ab]{1,3}(ab*|b)"
  "aabbbbb"
  '(:single-line nil)
  (list
    "aabb"
    "b" ) )

;;;; testinput1/457: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/457"
  "^[ab]{1,3}?(ab*|b)"
  "aabbbbb"
  '(:single-line nil)
  (list
    "aabbbbb"
    "abbbbb" ) )

;;;; testinput1/460: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/460"
  "^[ab]{1,3}?(ab*?|b)"
  "aabbbbb"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput1/463: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/463"
  "^[ab]{1,3}(ab*?|b)"
  "aabbbbb"
  '(:single-line nil)
  (list
    "aabb"
    "b" ) )

;;;; testinput1/659: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/659"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "Alan Other <user@dom.ain>"
  '(:extended-syntax t :single-line nil)
  (list "Alan Other <user@dom.ain>") )

;;;; testinput1/660: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/660"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "<user@dom.ain>"
  '(:extended-syntax t :single-line nil)
  (list "user@dom.ain") )

;;;; testinput1/661: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/661"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "user@dom.ain"
  '(:extended-syntax t :single-line nil)
  (list "user@dom.ain") )

;;;; testinput1/662: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/662"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "\"A. Other\" <user.1234@dom.ain> (a comment)"
  '(:extended-syntax t :single-line nil)
  (list "\"A. Other\" <user.1234@dom.ain> (a comment)") )

;;;; testinput1/663: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/663"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "A. Other <user.1234@dom.ain> (a comment)"
  '(:extended-syntax t :single-line nil)
  (list " Other <user.1234@dom.ain> (a comment)") )

;;;; testinput1/664: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/664"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"
  '(:extended-syntax t :single-line nil)
  (list "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay") )

;;;; testinput1/665: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/665"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "A missing angle <user@some.where"
  '(:extended-syntax t :single-line nil)
  (list "user@some.where") )

;;;; testinput1/666: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/666"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "*** Failers"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/667: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/667"
  (backslash "  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                          # optional leading comment\\n(?:    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n# address\\n|                     #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)             # one word, optionally followed by....\\n(?:\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037]  |  # atom and space parts, or...\\n\\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)       |  # comments, or...\\n\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n# quoted strings\\n)*\\n<  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                     # leading <\\n(?:  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  ,  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n)* # further okay, if led by comma\\n:                                # closing colon\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  )? #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)                    # initial word\\n(?:  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\" (?:                      # opening quote...\\n[^\\\\\\x80-\\xff\\n\\015\"]                #   Anything except backslash and quote\\n|                     #    or\\n\\\\ [^\\x80-\\xff]           #   Escaped something (something != CR)\\n)* \"  # closing quote\\n)  )* # further okay, if led by a period\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  @  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*    (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                           # initial subdomain\\n(?:                                  #\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  \\.                        # if led by a period...\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*   (?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|   \\[                         # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*    #    stuff\\n\\]                        #           ]\\n)                     #   ...further okay\\n)*\\n#       address spec\\n(?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*  > #                  trailing >\\n# name and address\\n)  (?: [\\040\\t] |  \\(\\n(?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  |  \\( (?:  [^\\\\\\x80-\\xff\\n\\015()]  |  \\\\ [^\\x80-\\xff]  )* \\)  )*\\n\\)  )*                       # optional trailing comment\\n")
  "The quick brown fox"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/1251: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1251"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "Alan Other <user@dom.ain>"
  '(:extended-syntax t :single-line nil)
  (list "Alan Other <user@dom.ain>") )

;;;; testinput1/1252: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1252"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "<user@dom.ain>"
  '(:extended-syntax t :single-line nil)
  (list "user@dom.ain") )

;;;; testinput1/1253: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1253"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "user@dom.ain"
  '(:extended-syntax t :single-line nil)
  (list "user@dom.ain") )

;;;; testinput1/1254: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1254"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "\"A. Other\" <user.1234@dom.ain> (a comment)"
  '(:extended-syntax t :single-line nil)
  (list "\"A. Other\" <user.1234@dom.ain>") )

;;;; testinput1/1255: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1255"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "A. Other <user.1234@dom.ain> (a comment)"
  '(:extended-syntax t :single-line nil)
  (list " Other <user.1234@dom.ain>") )

;;;; testinput1/1256: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1256"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay"
  '(:extended-syntax t :single-line nil)
  (list "\"/s=user/ou=host/o=place/prmd=uu.yy/admd= /c=gb/\"@x400-re.lay") )

;;;; testinput1/1257: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1257"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "A missing angle <user@some.where"
  '(:extended-syntax t :single-line nil)
  (list "user@some.where") )

;;;; testinput1/1258: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1258"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "*** Failers"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/1259: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1259"
  (backslash "[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional leading comment\\n(?:\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n# address\\n|                             #  or\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n# leading word\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *               # \"normal\" atoms and or spaces\\n(?:\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n|\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n) # \"special\" comment or quoted string\\n[^()<>@,;:\".\\\\\\x5B\\x5B\\x80-\\xff\\000-\\010\\012-\\037] *            #  more \"normal\"\\n)*\\n<\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# <\\n(?:\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n(?: ,\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n)*  # additional domains\\n:\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)?     #       optional route\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n# Atom\\n|                       #  or\\n\"                                     # \"\\n[^\\\\\\x80-\\xff\\n\\015\"] *                            #   normal\\n(?:  \\\\ [^\\x80-\\xff]  [^\\\\\\x80-\\xff\\n\\015\"] * )*        #   ( special normal* )*\\n\"                                     #        \"\\n# Quoted string\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# additional words\\n)*\\n@\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n(?:\\n\\.\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n(?:\\n[^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]+    # some number of atom characters...\\n(?![^(\\040)<>@,;:\".\\\\\\x5B\\x5B\\000-\\037\\x80-\\xff]) # ..not followed by something that could be part of an atom\\n|\\n\\[                            # [\\n(?: [^\\\\\\x80-\\xff\\n\\015\\x5B\\x5B] |  \\\\ [^\\x80-\\xff]  )*     #    stuff\\n\\]                           #           ]\\n)\\n[\\040\\t]*                    # Nab whitespace.\\n(?:\\n\\(                              #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                             #     normal*\\n(?:                                 #       (\\n(?:  \\\\ [^\\x80-\\xff]  |\\n\\(                            #  (\\n[^\\\\\\x80-\\xff\\n\\015()] *                            #     normal*\\n(?:  \\\\ [^\\x80-\\xff]   [^\\\\\\x80-\\xff\\n\\015()] * )*        #     (special normal*)*\\n\\)                           #                       )\\n)    #         special\\n[^\\\\\\x80-\\xff\\n\\015()] *                         #         normal*\\n)*                                  #            )*\\n\\)                             #                )\\n[\\040\\t]* )*    # If comment found, allow more spaces.\\n# optional trailing comments\\n)*\\n#       address spec\\n>                    #                 >\\n# name and address\\n)\\n")
  "The quick brown fox"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/1262: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1262"
  "abc\\0def\\00pqr\\000xyz\\0000AB"
  (backslash "abc\\u0000def\\u0000pqr\\u0000xyz\\u00000AB")
  '(:single-line nil)
  (list (backslash "abc\\u0000def\\u0000pqr\\u0000xyz\\u00000AB")) )

;;;; testinput1/1263: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1263"
  "abc\\0def\\00pqr\\000xyz\\0000AB"
  (backslash "abc456 abc\\u0000def\\u0000pqr\\u0000xyz\\u00000ABCDE")
  '(:single-line nil)
  (list (backslash "abc\\u0000def\\u0000pqr\\u0000xyz\\u00000AB")) )

;;;; testinput1/1266: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1266"
  "abc\\x0def\\x00pqr\\x000xyz\\x0000AB"
  (backslash "abc\\u000Def\\u0000pqr\\u00000xyz\\u000000AB")
  '(:single-line nil)
  (list (backslash "abc\\u000Def\\u0000pqr\\u00000xyz\\u000000AB")) )

;;;; testinput1/1267: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1267"
  "abc\\x0def\\x00pqr\\x000xyz\\x0000AB"
  (backslash "abc456 abc\\u000Def\\u0000pqr\\u00000xyz\\u000000ABCDE")
  '(:single-line nil)
  (list (backslash "abc\\u000Def\\u0000pqr\\u00000xyz\\u000000AB")) )

;;;; testinput1/1270: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1270"
  "^[\\000-\\037]"
  (backslash "\\u0000A")
  '(:single-line nil)
  (list (backslash "\\u0000")) )

;;;; testinput1/1271: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1271"
  "^[\\000-\\037]"
  (backslash "\\u0001B")
  '(:single-line nil)
  (list (backslash "\\u0001")) )

;;;; testinput1/1272: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1272"
  "^[\\000-\\037]"
  (backslash "\\u001FC")
  '(:single-line nil)
  (list (backslash "\\u001F")) )

;;;; testinput1/1275: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1275"
  "\\0*"
  (backslash "\\u0000\\u0000\\u0000\\u0000")
  '(:single-line nil)
  (list (backslash "\\u0000\\u0000\\u0000\\u0000")) )

;;;; testinput1/1278: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1278"
  "A\\x00{2,3}Z"
  (backslash "The A\\u0000\\u0000Z")
  '(:single-line nil)
  (list (backslash "A\\u0000\\u0000Z")) )

;;;; testinput1/1279: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1279"
  "A\\x00{2,3}Z"
  (backslash "An A\\u0000\\u0000\\u0000Z")
  '(:single-line nil)
  (list (backslash "A\\u0000\\u0000\\u0000Z")) )

;;;; testinput1/1280: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1280"
  "A\\x00{2,3}Z"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1281: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1281"
  "A\\x00{2,3}Z"
  (backslash "A\\u0000Z")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1282: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1282"
  "A\\x00{2,3}Z"
  (backslash "A\\u0000\\u0000\\u0000\\u0000Z")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1285: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1285"
  "^(cow|)\\1(bell)"
  "cowcowbell"
  '(:single-line nil)
  (list
    "cowcowbell"
    "cow"
    "bell" ) )

;;;; testinput1/1286: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1286"
  "^(cow|)\\1(bell)"
  "bell"
  '(:single-line nil)
  (list
    "bell"
    ""
    "bell" ) )

;;;; testinput1/1287: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1287"
  "^(cow|)\\1(bell)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1288: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1288"
  "^(cow|)\\1(bell)"
  "cowbell"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1291: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1291"
  "^\\s"
  " abc"
  '(:single-line nil)
  (list " ") )

;;;; testinput1/1292: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1292"
  "^\\s"
  (backslash "\\u000Cabc")
  '(:single-line nil)
  (list (backslash "\\u000C")) )

;;;; testinput1/1293: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1293"
  "^\\s"
  (backslash "\\nabc")
  '(:single-line nil)
  (list "
") )

;;;; testinput1/1294: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1294"
  "^\\s"
  (backslash "\\u000Dabc")
  '(:single-line nil)
  (list (backslash "\\u000D")) )

;;;; testinput1/1295: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1295"
  "^\\s"
  (backslash "\\tabc")
  '(:single-line nil)
  (list (backslash "\\t")) )

;;;; testinput1/1296: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1296"
  "^\\s"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1297: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1297"
  "^\\s"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1301: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1301"
  (backslash "^a\\tb\\n  \\u000D  \\u000C  c")
  "abc"
  '(:extended-syntax t :single-line nil)
  (list "abc") )

;;;; testinput1/1304: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1304"
  "^(a|)\\1*b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput1/1305: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1305"
  "^(a|)\\1*b"
  "aaaab"
  '(:single-line nil)
  (list
    "aaaab"
    "a" ) )

;;;; testinput1/1306: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1306"
  "^(a|)\\1*b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput1/1307: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1307"
  "^(a|)\\1*b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1308: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1308"
  "^(a|)\\1*b"
  "acb"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1311: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1311"
  "^(a|)\\1+b"
  "aab"
  '(:single-line nil)
  (list
    "aab"
    "a" ) )

;;;; testinput1/1312: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1312"
  "^(a|)\\1+b"
  "aaaab"
  '(:single-line nil)
  (list
    "aaaab"
    "a" ) )

;;;; testinput1/1313: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1313"
  "^(a|)\\1+b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput1/1314: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1314"
  "^(a|)\\1+b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1315: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1315"
  "^(a|)\\1+b"
  "ab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1318: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1318"
  "^(a|)\\1?b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput1/1319: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1319"
  "^(a|)\\1?b"
  "aab"
  '(:single-line nil)
  (list
    "aab"
    "a" ) )

;;;; testinput1/1320: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1320"
  "^(a|)\\1?b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput1/1321: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1321"
  "^(a|)\\1?b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1322: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1322"
  "^(a|)\\1?b"
  "acb"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1325: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1325"
  "^(a|)\\1{2}b"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "a" ) )

;;;; testinput1/1326: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1326"
  "^(a|)\\1{2}b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput1/1327: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1327"
  "^(a|)\\1{2}b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1328: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1328"
  "^(a|)\\1{2}b"
  "ab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1329: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1329"
  "^(a|)\\1{2}b"
  "aab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1330: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1330"
  "^(a|)\\1{2}b"
  "aaaab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1333: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1333"
  "^(a|)\\1{2,3}b"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "a" ) )

;;;; testinput1/1334: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1334"
  "^(a|)\\1{2,3}b"
  "aaaab"
  '(:single-line nil)
  (list
    "aaaab"
    "a" ) )

;;;; testinput1/1335: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1335"
  "^(a|)\\1{2,3}b"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput1/1336: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1336"
  "^(a|)\\1{2,3}b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1337: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1337"
  "^(a|)\\1{2,3}b"
  "ab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1338: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1338"
  "^(a|)\\1{2,3}b"
  "aab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1339: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1339"
  "^(a|)\\1{2,3}b"
  "aaaaab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1342: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1342"
  "ab{1,3}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput1/1343: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1343"
  "ab{1,3}bc"
  "abbbc"
  '(:single-line nil)
  (list "abbbc") )

;;;; testinput1/1344: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1344"
  "ab{1,3}bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; testinput1/1345: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1345"
  "ab{1,3}bc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1346: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1346"
  "ab{1,3}bc"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1347: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1347"
  "ab{1,3}bc"
  "abbbbbc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1350: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/1350"
  "([^.]*)\\.([^:]*):[T ]+(.*)"
  "track1.title:TBlah blah blah"
  '(:single-line nil)
  (list
    "track1.title:TBlah blah blah"
    "track1"
    "title"
    "Blah blah blah" ) )

;;;; testinput1/1353: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/1353"
  "([^.]*)\\.([^:]*):[T ]+(.*)"
  "track1.title:TBlah blah blah"
  '(:ignore-case t :single-line nil)
  (list
    "track1.title:TBlah blah blah"
    "track1"
    "title"
    "Blah blah blah" ) )

;;;; testinput1/1356: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/1356"
  "([^.]*)\\.([^:]*):[t ]+(.*)"
  "track1.title:TBlah blah blah"
  '(:ignore-case t :single-line nil)
  (list
    "track1.title:TBlah blah blah"
    "track1"
    "title"
    "Blah blah blah" ) )

;;;; testinput1/1359: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1359"
  "^[W-c]+$"
  "WXY_^abc"
  '(:single-line nil)
  (list "WXY_^abc") )

;;;; testinput1/1360: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1360"
  "^[W-c]+$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1361: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1361"
  "^[W-c]+$"
  "wxy"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1364: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1364"
  "^[W-c]+$"
  "WXY_^abc"
  '(:ignore-case t :single-line nil)
  (list "WXY_^abc") )

;;;; testinput1/1365: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1365"
  "^[W-c]+$"
  "wxy_^ABC"
  '(:ignore-case t :single-line nil)
  (list "wxy_^ABC") )

;;;; testinput1/1368: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1368"
  "^[\\x3f-\\x5F]+$"
  "WXY_^abc"
  '(:ignore-case t :single-line nil)
  (list "WXY_^abc") )

;;;; testinput1/1369: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1369"
  "^[\\x3f-\\x5F]+$"
  "wxy_^ABC"
  '(:ignore-case t :single-line nil)
  (list "wxy_^ABC") )

;;;; testinput1/1372: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1372"
  "^abc$"
  "abc"
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput1/1373: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1373"
  "^abc$"
  (backslash "qqq\\nabc")
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput1/1374: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1374"
  "^abc$"
  (backslash "abc\\nzzz")
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput1/1375: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1375"
  "^abc$"
  (backslash "qqq\\nabc\\nzzz")
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput1/1378: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1378"
  "^abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/1379: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1379"
  "^abc$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1380: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1380"
  "^abc$"
  (backslash "qqq\\nabc")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1381: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1381"
  "^abc$"
  (backslash "abc\\nzzz")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1382: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1382"
  "^abc$"
  (backslash "qqq\\nabc\\nzzz")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1385: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1385"
  "\\Aabc\\Z"
  "abc"
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput1/1386: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1386"
  "\\Aabc\\Z"
  "abc
"
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput1/1387: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1387"
  "\\Aabc\\Z"
  "*** Failers"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1388: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1388"
  "\\Aabc\\Z"
  (backslash "qqq\\nabc")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1389: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1389"
  "\\Aabc\\Z"
  (backslash "abc\\nzzz")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1390: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1390"
  "\\Aabc\\Z"
  (backslash "qqq\\nabc\\nzzz")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1393: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1393"
  "\\A(.)*\\Z"
  (backslash "abc\\ndef")
  '(:single-line t)
  (list
    (backslash "abc\\ndef")
    "f" ) )

;;;; testinput1/1396: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1396"
  "\\A(.)*\\Z"
  "*** Failers"
  '(:multiple-lines t :single-line nil)
  (list
    "*** Failers"
    "s" ) )

;;;; testinput1/1397: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1397"
  "\\A(.)*\\Z"
  (backslash "abc\\ndef")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1400: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1400"
  "(?:b)|(?::+)"
  "b::c"
  '(:single-line nil)
  (list "b") )

;;;; testinput1/1401: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1401"
  "(?:b)|(?::+)"
  "c::b"
  '(:single-line nil)
  (list "::") )

;;;; testinput1/1404: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1404"
  "[-az]+"
  "az-"
  '(:single-line nil)
  (list "az-") )

;;;; testinput1/1405: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1405"
  "[-az]+"
  "*** Failers"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/1406: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1406"
  "[-az]+"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1409: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1409"
  "[az-]+"
  "za-"
  '(:single-line nil)
  (list "za-") )

;;;; testinput1/1410: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1410"
  "[az-]+"
  "*** Failers"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/1411: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1411"
  "[az-]+"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1414: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1414"
  "[a\\-z]+"
  "a-z"
  '(:single-line nil)
  (list "a-z") )

;;;; testinput1/1415: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1415"
  "[a\\-z]+"
  "*** Failers"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/1416: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1416"
  "[a\\-z]+"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1419: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1419"
  "[a-z]+"
  "abcdxyz"
  '(:single-line nil)
  (list "abcdxyz") )

;;;; testinput1/1422: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1422"
  "[\\d-]+"
  "12-34"
  '(:single-line nil)
  (list "12-34") )

;;;; testinput1/1423: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1423"
  "[\\d-]+"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1424: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1424"
  "[\\d-]+"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1427: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1427"
  "[\\d-z]+"
  "12-34z"
  '(:single-line nil)
  (list "12-34z") )

;;;; testinput1/1428: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1428"
  "[\\d-z]+"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1429: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1429"
  "[\\d-z]+"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1432: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1432"
  "\\x5c"
  "\\"
  '(:single-line nil)
  (list "\\") )

;;;; testinput1/1435: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1435"
  "\\x20Z"
  "the Zoo"
  '(:single-line nil)
  (list " Z") )

;;;; testinput1/1436: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1436"
  "\\x20Z"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1437: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1437"
  "\\x20Z"
  "Zulu"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1440: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1440"
  "(abc)\\1"
  "abcabc"
  '(:ignore-case t :single-line nil)
  (list
    "abcabc"
    "abc" ) )

;;;; testinput1/1441: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1441"
  "(abc)\\1"
  "ABCabc"
  '(:ignore-case t :single-line nil)
  (list
    "ABCabc"
    "ABC" ) )

;;;; testinput1/1442: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1442"
  "(abc)\\1"
  "abcABC"
  '(:ignore-case t :single-line nil)
  (list
    "abcABC"
    "abc" ) )

;;;; testinput1/1445: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1445"
  "ab{3cd"
  "ab{3cd"
  '(:single-line nil)
  (list "ab{3cd") )

;;;; testinput1/1448: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1448"
  "ab{3,cd"
  "ab{3,cd"
  '(:single-line nil)
  (list "ab{3,cd") )

;;;; testinput1/1451: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1451"
  "ab{3,4a}cd"
  "ab{3,4a}cd"
  '(:single-line nil)
  (list "ab{3,4a}cd") )

;;;; testinput1/1454: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1454"
  "{4,5a}bc"
  "{4,5a}bc"
  '(:single-line nil)
  (list "{4,5a}bc") )

;;;; testinput1/1457: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1457"
  "^a.b"
  (backslash "a\\u000Db")
  '(:single-line nil)
  (list (backslash "a\\u000Db")) )

;;;; testinput1/1458: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1458"
  "^a.b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1459: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1459"
  "^a.b"
  (backslash "a\\nb")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1462: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1462"
  "abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/1463: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1463"
  "abc$"
  "abc
"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/1464: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1464"
  "abc$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1465: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1465"
  "abc$"
  (backslash "abc\\ndef")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1468: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1468"
  "(abc)\\123"
  "abcS"
  '(:single-line nil)
  (list
    "abcS"
    "abc" ) )

;;;; testinput1/1471: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1471"
  "(abc)\\223"
  (backslash "abc\\u0093")
  '(:single-line nil)
  (list
    (backslash "abc\\u0093")
    "abc" ) )

;;;; testinput1/1474: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1474"
  "(abc)\\323"
  (backslash "abc\\u00D3")
  '(:single-line nil)
  (list
    (backslash "abc\\u00D3")
    "abc" ) )

;;;; testinput1/1477: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1477"
  "(abc)\\500"
  "abc@"
  '(:single-line nil)
  (list
    "abc@"
    "abc" ) )

;;;; testinput1/1478: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1478"
  "(abc)\\500"
  "abc@"
  '(:single-line nil)
  (list
    "abc@"
    "abc" ) )

;;;; testinput1/1481: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1481"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput1/1482: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1482"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput1/1483: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1483"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput1/1484: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1484"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput1/1485: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1485"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput1/1486: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1486"
  "(abc)\\5000"
  "abc@0"
  '(:single-line nil)
  (list
    "abc@0"
    "abc" ) )

;;;; testinput1/1489: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1489"
  "abc\\81"
  (backslash "abc\\u000081")
  '(:single-line nil)
  (list (backslash "abc\\u000081")) )

;;;; testinput1/1490: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1490"
  "abc\\81"
  (backslash "abc\\u000081")
  '(:single-line nil)
  (list (backslash "abc\\u000081")) )

;;;; testinput1/1493: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1493"
  "abc\\91"
  (backslash "abc\\u000091")
  '(:single-line nil)
  (list (backslash "abc\\u000091")) )

;;;; testinput1/1494: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1494"
  "abc\\91"
  (backslash "abc\\u000091")
  '(:single-line nil)
  (list (backslash "abc\\u000091")) )

;;;; testinput1/1497: 
;;;
;;;    Matched with 12 captures.
;
(test-case
  "pcre-1/1497"
  "(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\12\\123"
  "abcdefghijkllS"
  '(:single-line nil)
  (list
    "abcdefghijkllS"
    "a"
    "b"
    "c"
    "d"
    "e"
    "f"
    "g"
    "h"
    "i"
    "j"
    "k"
    "l" ) )

;;;; testinput1/1500: 
;;;
;;;    Matched with 11 captures.
;
(test-case
  "pcre-1/1500"
  "(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\12\\123"
  (backslash "abcdefghijk\\nS")
  '(:single-line nil)
  (list
    (backslash "abcdefghijk\\nS")
    "a"
    "b"
    "c"
    "d"
    "e"
    "f"
    "g"
    "h"
    "i"
    "j"
    "k" ) )

;;;; testinput1/1503: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1503"
  "ab\\gdef"
  "abgdef"
  '(:single-line nil)
  (list "abgdef") )

;;;; testinput1/1506: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1506"
  "a{0}bc"
  "bc"
  '(:single-line nil)
  (list "bc") )

;;;; testinput1/1509: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1509"
  "(a|(bc)){0,0}?xyz"
  "xyz"
  '(:single-line nil)
  (list "xyz") )

;;;; testinput1/1512: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1512"
  "abc[\\10]de"
  (backslash "abc\\u0008de")
  '(:single-line nil)
  (list (backslash "abc\\u0008de")) )

;;;; testinput1/1515: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1515"
  "abc[\\1]de"
  (backslash "abc\\u0001de")
  '(:single-line nil)
  (list (backslash "abc\\u0001de")) )

;;;; testinput1/1518: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1518"
  "(abc)[\\1]de"
  (backslash "abc\\u0001de")
  '(:single-line nil)
  (list
    (backslash "abc\\u0001de")
    "abc" ) )

;;;; testinput1/1521: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1521"
  "(?s)a.b"
  (backslash "a\\nb")
  '(:single-line nil)
  (list (backslash "a\\nb")) )

;;;; testinput1/1524: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/1524"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "baNOTccccd"
  '(:single-line nil)
  (list
    "baNOTcccc"
    "b"
    "a"
    "NOT"
    "cccc" ) )

;;;; testinput1/1525: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/1525"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "baNOTcccd"
  '(:single-line nil)
  (list
    "baNOTccc"
    "b"
    "a"
    "NOT"
    "ccc" ) )

;;;; testinput1/1526: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/1526"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "baNOTccd"
  '(:single-line nil)
  (list
    "baNOTcc"
    "b"
    "a"
    "NO"
    "Tcc" ) )

;;;; testinput1/1527: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/1527"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "bacccd"
  '(:single-line nil)
  (list
    "baccc"
    "b"
    "a"
    ""
    "ccc" ) )

;;;; testinput1/1528: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/1528"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "*** Failers"
  '(:single-line nil)
  (list
    "*** Failers"
    "*"
    "*"
    "* Fail"
    "ers" ) )

;;;; testinput1/1529: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1529"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "anything"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1530: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1530"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  (backslash "b\\u0008c")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1531: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1531"
  "^([^a])([^\\b])([^c]*)([^d]{3,4})"
  "baccd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1534: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1534"
  "[^a]"
  "Abc"
  '(:single-line nil)
  (list "A") )

;;;; testinput1/1537: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1537"
  "[^a]"
  "Abc"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput1/1540: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1540"
  "[^a]+"
  "AAAaAbc"
  '(:single-line nil)
  (list "AAA") )

;;;; testinput1/1543: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1543"
  "[^a]+"
  "AAAaAbc"
  '(:ignore-case t :single-line nil)
  (list "bc") )

;;;; testinput1/1546: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1546"
  "[^a]+"
  (backslash "bbb\\nccc")
  '(:single-line nil)
  (list (backslash "bbb\\nccc")) )

;;;; testinput1/1549: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1549"
  "[^k]$"
  "abc"
  '(:single-line nil)
  (list "c") )

;;;; testinput1/1550: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1550"
  "[^k]$"
  "*** Failers"
  '(:single-line nil)
  (list "s") )

;;;; testinput1/1551: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1551"
  "[^k]$"
  "abk"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1554: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1554"
  "[^k]{2,3}$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/1555: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1555"
  "[^k]{2,3}$"
  "kbc"
  '(:single-line nil)
  (list "bc") )

;;;; testinput1/1556: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1556"
  "[^k]{2,3}$"
  "kabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/1557: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1557"
  "[^k]{2,3}$"
  "*** Failers"
  '(:single-line nil)
  (list "ers") )

;;;; testinput1/1558: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1558"
  "[^k]{2,3}$"
  "abk"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1559: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1559"
  "[^k]{2,3}$"
  "akb"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1560: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1560"
  "[^k]{2,3}$"
  "akk"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1563: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1563"
  "^\\d{8,}@.+[^k]$"
  "12345678@a.b.c.d"
  '(:single-line nil)
  (list "12345678@a.b.c.d") )

;;;; testinput1/1564: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1564"
  "^\\d{8,}@.+[^k]$"
  "123456789@x.y.z"
  '(:single-line nil)
  (list "123456789@x.y.z") )

;;;; testinput1/1565: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1565"
  "^\\d{8,}@.+[^k]$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1566: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1566"
  "^\\d{8,}@.+[^k]$"
  "12345678@x.y.uk"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1567: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1567"
  "^\\d{8,}@.+[^k]$"
  "1234567@a.b.c.d"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1570: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1570"
  "(a)\\1{8,}"
  "aaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaa"
    "a" ) )

;;;; testinput1/1571: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1571"
  "(a)\\1{8,}"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "a" ) )

;;;; testinput1/1572: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1572"
  "(a)\\1{8,}"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1573: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1573"
  "(a)\\1{8,}"
  "aaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1576: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1576"
  "[^a]"
  "aaaabcd"
  '(:single-line nil)
  (list "b") )

;;;; testinput1/1577: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1577"
  "[^a]"
  "aaAabcd"
  '(:single-line nil)
  (list "A") )

;;;; testinput1/1580: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1580"
  "[^a]"
  "aaaabcd"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput1/1581: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1581"
  "[^a]"
  "aaAabcd"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput1/1584: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1584"
  "[^az]"
  "aaaabcd"
  '(:single-line nil)
  (list "b") )

;;;; testinput1/1585: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1585"
  "[^az]"
  "aaAabcd"
  '(:single-line nil)
  (list "A") )

;;;; testinput1/1588: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1588"
  "[^az]"
  "aaaabcd"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput1/1589: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1589"
  "[^az]"
  "aaAabcd"
  '(:ignore-case t :single-line nil)
  (list "b") )

;;;; testinput1/1592: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1592"
  "\\000\\001\\002\\003\\004\\005\\006\\007\\010\\011\\012\\013\\014\\015\\016\\017\\020\\021\\022\\023\\024\\025\\026\\027\\030\\031\\032\\033\\034\\035\\036\\037\\040\\041\\042\\043\\044\\045\\046\\047\\050\\051\\052\\053\\054\\055\\056\\057\\060\\061\\062\\063\\064\\065\\066\\067\\070\\071\\072\\073\\074\\075\\076\\077\\100\\101\\102\\103\\104\\105\\106\\107\\110\\111\\112\\113\\114\\115\\116\\117\\120\\121\\122\\123\\124\\125\\126\\127\\130\\131\\132\\133\\134\\135\\136\\137\\140\\141\\142\\143\\144\\145\\146\\147\\150\\151\\152\\153\\154\\155\\156\\157\\160\\161\\162\\163\\164\\165\\166\\167\\170\\171\\172\\173\\174\\175\\176\\177\\200\\201\\202\\203\\204\\205\\206\\207\\210\\211\\212\\213\\214\\215\\216\\217\\220\\221\\222\\223\\224\\225\\226\\227\\230\\231\\232\\233\\234\\235\\236\\237\\240\\241\\242\\243\\244\\245\\246\\247\\250\\251\\252\\253\\254\\255\\256\\257\\260\\261\\262\\263\\264\\265\\266\\267\\270\\271\\272\\273\\274\\275\\276\\277\\300\\301\\302\\303\\304\\305\\306\\307\\310\\311\\312\\313\\314\\315\\316\\317\\320\\321\\322\\323\\324\\325\\326\\327\\330\\331\\332\\333\\334\\335\\336\\337\\340\\341\\342\\343\\344\\345\\346\\347\\350\\351\\352\\353\\354\\355\\356\\357\\360\\361\\362\\363\\364\\365\\366\\367\\370\\371\\372\\373\\374\\375\\376\\377"
  (backslash "\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\u0008\\t\\n\\u000B\\u000C\\u000D\\u000E\\u000F\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001A\\u001B\\u001C\\u001D\\u001E\\u001F !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\u007F\\u0080\\u0081\\u0082\\u0083\\u0084\\u0085\\u0086\\u0087\\u0088\\u0089\\u008A\\u008B\\u008C\\u008D\\u008E\\u008F\\u0090\\u0091\\u0092\\u0093\\u0094\\u0095\\u0096\\u0097\\u0098\\u0099\\u009A\\u009B\\u009C\\u009D\\u009E\\u009F\\u00A0\\u00A1\\u00A2\\u00A3\\u00A4\\u00A5\\u00A6\\u00A7\\u00A8\\u00A9\\u00AA\\u00AB\\u00AC\\u00AD\\u00AE\\u00AF\\u00B0\\u00B1\\u00B2\\u00B3\\u00B4\\u00B5\\u00B6\\u00B7\\u00B8\\u00B9\\u00BA\\u00BB\\u00BC\\u00BD\\u00BE\\u00BF\\u00C0\\u00C1\\u00C2\\u00C3\\u00C4\\u00C5\\u00C6\\u00C7\\u00C8\\u00C9\\u00CA\\u00CB\\u00CC\\u00CD\\u00CE\\u00CF\\u00D0\\u00D1\\u00D2\\u00D3\\u00D4\\u00D5\\u00D6\\u00D7\\u00D8\\u00D9\\u00DA\\u00DB\\u00DC\\u00DD\\u00DE\\u00DF\\u00E0\\u00E1\\u00E2\\u00E3\\u00E4\\u00E5\\u00E6\\u00E7\\u00E8\\u00E9\\u00EA\\u00EB\\u00EC\\u00ED\\u00EE\\u00EF\\u00F0\\u00F1\\u00F2\\u00F3\\u00F4\\u00F5\\u00F6\\u00F7\\u00F8\\u00F9\\u00FA\\u00FB\\u00FC\\u00FD\\u00FE\\u00FF")
  '(:single-line nil)
  (list (backslash "\\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\u0008\\t\\n\\u000B\\u000C\\u000D\\u000E\\u000F\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001A\\u001B\\u001C\\u001D\\u001E\\u001F !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\u007F\\u0080\\u0081\\u0082\\u0083\\u0084\\u0085\\u0086\\u0087\\u0088\\u0089\\u008A\\u008B\\u008C\\u008D\\u008E\\u008F\\u0090\\u0091\\u0092\\u0093\\u0094\\u0095\\u0096\\u0097\\u0098\\u0099\\u009A\\u009B\\u009C\\u009D\\u009E\\u009F\\u00A0\\u00A1\\u00A2\\u00A3\\u00A4\\u00A5\\u00A6\\u00A7\\u00A8\\u00A9\\u00AA\\u00AB\\u00AC\\u00AD\\u00AE\\u00AF\\u00B0\\u00B1\\u00B2\\u00B3\\u00B4\\u00B5\\u00B6\\u00B7\\u00B8\\u00B9\\u00BA\\u00BB\\u00BC\\u00BD\\u00BE\\u00BF\\u00C0\\u00C1\\u00C2\\u00C3\\u00C4\\u00C5\\u00C6\\u00C7\\u00C8\\u00C9\\u00CA\\u00CB\\u00CC\\u00CD\\u00CE\\u00CF\\u00D0\\u00D1\\u00D2\\u00D3\\u00D4\\u00D5\\u00D6\\u00D7\\u00D8\\u00D9\\u00DA\\u00DB\\u00DC\\u00DD\\u00DE\\u00DF\\u00E0\\u00E1\\u00E2\\u00E3\\u00E4\\u00E5\\u00E6\\u00E7\\u00E8\\u00E9\\u00EA\\u00EB\\u00EC\\u00ED\\u00EE\\u00EF\\u00F0\\u00F1\\u00F2\\u00F3\\u00F4\\u00F5\\u00F6\\u00F7\\u00F8\\u00F9\\u00FA\\u00FB\\u00FC\\u00FD\\u00FE\\u00FF")) )

;;;; testinput1/1595: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1595"
  "P[^*]TAIRE[^*]{1,6}?LL"
  "xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"
  '(:single-line nil)
  (list "PSTAIREISLL") )

;;;; testinput1/1598: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1598"
  "P[^*]TAIRE[^*]{1,}?LL"
  "xxxxxxxxxxxPSTAIREISLLxxxxxxxxx"
  '(:single-line nil)
  (list "PSTAIREISLL") )

;;;; testinput1/1601: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1601"
  "(\\.\\d\\d[1-9]?)\\d+"
  "1.230003938"
  '(:single-line nil)
  (list
    ".230003938"
    ".23" ) )

;;;; testinput1/1602: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1602"
  "(\\.\\d\\d[1-9]?)\\d+"
  "1.875000282"
  '(:single-line nil)
  (list
    ".875000282"
    ".875" ) )

;;;; testinput1/1603: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1603"
  "(\\.\\d\\d[1-9]?)\\d+"
  "1.235"
  '(:single-line nil)
  (list
    ".235"
    ".23" ) )

;;;; testinput1/1606: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1606"
  "(\\.\\d\\d((?=0)|\\d(?=\\d)))"
  "1.230003938"
  '(:single-line nil)
  (list
    ".23"
    ".23"
    "" ) )

;;;; testinput1/1607: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1607"
  "(\\.\\d\\d((?=0)|\\d(?=\\d)))"
  "1.875000282"
  '(:single-line nil)
  (list
    ".875"
    ".875"
    "5" ) )

;;;; testinput1/1608: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1608"
  "(\\.\\d\\d((?=0)|\\d(?=\\d)))"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1609: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1609"
  "(\\.\\d\\d((?=0)|\\d(?=\\d)))"
  "1.235"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1612: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1612"
  "a(?)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput1/1615: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1615"
  "\\b(foo)\\s+(\\w+)"
  "Food is on the foo table"
  '(:ignore-case t :single-line nil)
  (list
    "foo table"
    "foo"
    "table" ) )

;;;; testinput1/1618: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1618"
  "foo(.*)bar"
  "The food is under the bar in the barn."
  '(:single-line nil)
  (list
    "food is under the bar in the bar"
    "d is under the bar in the " ) )

;;;; testinput1/1621: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1621"
  "foo(.*?)bar"
  "The food is under the bar in the barn."
  '(:single-line nil)
  (list
    "food is under the bar"
    "d is under the " ) )

;;;; testinput1/1624: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1624"
  "(.*)(\\d*)"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: 53147"
    "" ) )

;;;; testinput1/1627: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1627"
  "(.*)(\\d+)"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: 5314"
    "7" ) )

;;;; testinput1/1630: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1630"
  "(.*?)(\\d*)"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    ""
    ""
    "" ) )

;;;; testinput1/1633: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1633"
  "(.*?)(\\d+)"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2"
    "I have "
    "2" ) )

;;;; testinput1/1636: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1636"
  "(.*)(\\d+)$"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: 5314"
    "7" ) )

;;;; testinput1/1639: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1639"
  "(.*?)(\\d+)$"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: "
    "53147" ) )

;;;; testinput1/1642: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1642"
  "(.*)\\b(\\d+)$"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: "
    "53147" ) )

;;;; testinput1/1645: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1645"
  "(.*\\D)(\\d+)$"
  "I have 2 numbers: 53147"
  '(:single-line nil)
  (list
    "I have 2 numbers: 53147"
    "I have 2 numbers: "
    "53147" ) )

;;;; testinput1/1648: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1648"
  "^\\D*(?!123)"
  "ABC123"
  '(:single-line nil)
  (list "AB") )

;;;; testinput1/1651: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1651"
  "^(\\D*)(?=\\d)(?!123)"
  "ABC445"
  '(:single-line nil)
  (list
    "ABC"
    "ABC" ) )

;;;; testinput1/1652: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1652"
  "^(\\D*)(?=\\d)(?!123)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1653: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1653"
  "^(\\D*)(?=\\d)(?!123)"
  "ABC123"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1656: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1656"
  "^[W-]46]"
  "W46]789"
  '(:single-line nil)
  (list "W46]") )

;;;; testinput1/1657: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1657"
  "^[W-]46]"
  "-46]789"
  '(:single-line nil)
  (list "-46]") )

;;;; testinput1/1658: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1658"
  "^[W-]46]"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1659: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1659"
  "^[W-]46]"
  "Wall"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1660: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1660"
  "^[W-]46]"
  "Zebra"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1661: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1661"
  "^[W-]46]"
  "42"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1662: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1662"
  "^[W-]46]"
  "[abcd]"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1663: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1663"
  "^[W-]46]"
  "]abcd["
  '(:single-line nil)
  nil
 )

;;;; testinput1/1666: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1666"
  "^[W-\\]46]"
  "W46]789"
  '(:single-line nil)
  (list "W") )

;;;; testinput1/1667: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1667"
  "^[W-\\]46]"
  "Wall"
  '(:single-line nil)
  (list "W") )

;;;; testinput1/1668: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1668"
  "^[W-\\]46]"
  "Zebra"
  '(:single-line nil)
  (list "Z") )

;;;; testinput1/1669: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1669"
  "^[W-\\]46]"
  "Xylophone"
  '(:single-line nil)
  (list "X") )

;;;; testinput1/1670: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1670"
  "^[W-\\]46]"
  "42"
  '(:single-line nil)
  (list "4") )

;;;; testinput1/1671: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1671"
  "^[W-\\]46]"
  "[abcd]"
  '(:single-line nil)
  (list "[") )

;;;; testinput1/1672: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1672"
  "^[W-\\]46]"
  "]abcd["
  '(:single-line nil)
  (list "]") )

;;;; testinput1/1673: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1673"
  "^[W-\\]46]"
  "\\backslash"
  '(:single-line nil)
  (list "\\") )

;;;; testinput1/1674: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1674"
  "^[W-\\]46]"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1675: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1675"
  "^[W-\\]46]"
  "-46]789"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1676: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1676"
  "^[W-\\]46]"
  "well"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1679: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1679"
  "\\d\\d/\\d\\d/\\d\\d\\d\\d"
  "01/01/2000"
  '(:single-line nil)
  (list "01/01/2000") )

;;;; testinput1/1682: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1682"
  "word (?:[a-zA-Z0-9]+ ){0,10}otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark otherword"
  '(:single-line nil)
  (list "word cat dog elephant mussel cow horse canary baboon snake shark otherword") )

;;;; testinput1/1683: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1683"
  "word (?:[a-zA-Z0-9]+ ){0,10}otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1686: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1686"
  "word (?:[a-zA-Z0-9]+ ){0,300}otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1689: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1689"
  "^(a){0,0}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput1/1690: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1690"
  "^(a){0,0}"
  "abc"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput1/1691: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1691"
  "^(a){0,0}"
  "aab"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput1/1694: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1694"
  "^(a){0,1}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput1/1695: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1695"
  "^(a){0,1}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1696: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1696"
  "^(a){0,1}"
  "aab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1699: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1699"
  "^(a){0,2}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput1/1700: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1700"
  "^(a){0,2}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1701: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1701"
  "^(a){0,2}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput1/1704: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1704"
  "^(a){0,3}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput1/1705: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1705"
  "^(a){0,3}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1706: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1706"
  "^(a){0,3}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput1/1707: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1707"
  "^(a){0,3}"
  "aaa"
  '(:single-line nil)
  (list
    "aaa"
    "a" ) )

;;;; testinput1/1710: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1710"
  "^(a){0,}"
  "bcd"
  '(:single-line nil)
  (list
    ""
    nil ) )

;;;; testinput1/1711: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1711"
  "^(a){0,}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1712: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1712"
  "^(a){0,}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput1/1713: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1713"
  "^(a){0,}"
  "aaa"
  '(:single-line nil)
  (list
    "aaa"
    "a" ) )

;;;; testinput1/1714: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1714"
  "^(a){0,}"
  "aaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaa"
    "a" ) )

;;;; testinput1/1717: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1717"
  "^(a){1,1}"
  "bcd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1718: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1718"
  "^(a){1,1}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1719: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1719"
  "^(a){1,1}"
  "aab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1722: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1722"
  "^(a){1,2}"
  "bcd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1723: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1723"
  "^(a){1,2}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1724: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1724"
  "^(a){1,2}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput1/1727: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1727"
  "^(a){1,3}"
  "bcd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1728: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1728"
  "^(a){1,3}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1729: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1729"
  "^(a){1,3}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput1/1730: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1730"
  "^(a){1,3}"
  "aaa"
  '(:single-line nil)
  (list
    "aaa"
    "a" ) )

;;;; testinput1/1733: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1733"
  "^(a){1,}"
  "bcd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1734: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1734"
  "^(a){1,}"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/1735: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1735"
  "^(a){1,}"
  "aab"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput1/1736: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1736"
  "^(a){1,}"
  "aaa"
  '(:single-line nil)
  (list
    "aaa"
    "a" ) )

;;;; testinput1/1737: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1737"
  "^(a){1,}"
  "aaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaa"
    "a" ) )

;;;; testinput1/1740: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1740"
  ".*\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line nil)
  (list "bib.gif") )

;;;; testinput1/1743: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1743"
  ".{0,}\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line nil)
  (list "bib.gif") )

;;;; testinput1/1746: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1746"
  ".*\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:multiple-lines t :single-line nil)
  (list "bib.gif") )

;;;; testinput1/1749: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1749"
  ".*\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line t)
  (list (backslash "borfle\\nbib.gif")) )

;;;; testinput1/1752: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1752"
  ".*\\.gif"
  (backslash "borfle\\nbib.gif\\nno")
  '(:multiple-lines t :single-line t)
  (list (backslash "borfle\\nbib.gif")) )

;;;; testinput1/1755: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1755"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line nil)
  (list "no") )

;;;; testinput1/1758: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1758"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno")
  '(:multiple-lines t :single-line nil)
  (list "borfle") )

;;;; testinput1/1761: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1761"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno")
  '(:single-line t)
  (list (backslash "borfle\\nbib.gif\\nno")) )

;;;; testinput1/1764: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1764"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno")
  '(:multiple-lines t :single-line t)
  (list (backslash "borfle\\nbib.gif\\nno")) )

;;;; testinput1/1767: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1767"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno\\n")
  '(:single-line nil)
  (list "no") )

;;;; testinput1/1770: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1770"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno\\n")
  '(:multiple-lines t :single-line nil)
  (list "borfle") )

;;;; testinput1/1773: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1773"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno\\n")
  '(:single-line t)
  (list (backslash "borfle\\nbib.gif\\nno\\n")) )

;;;; testinput1/1776: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1776"
  ".*$"
  (backslash "borfle\\nbib.gif\\nno\\n")
  '(:multiple-lines t :single-line t)
  (list (backslash "borfle\\nbib.gif\\nno\\n")) )

;;;; testinput1/1779: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1779"
  "(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:single-line nil)
  (list
    "1234X"
    "1234X" ) )

;;;; testinput1/1780: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1780"
  "(.*X|^B)"
  "BarFoo"
  '(:single-line nil)
  (list
    "B"
    "B" ) )

;;;; testinput1/1781: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1781"
  "(.*X|^B)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1782: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1782"
  "(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1785: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1785"
  "(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:multiple-lines t :single-line nil)
  (list
    "1234X"
    "1234X" ) )

;;;; testinput1/1786: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1786"
  "(.*X|^B)"
  "BarFoo"
  '(:multiple-lines t :single-line nil)
  (list
    "B"
    "B" ) )

;;;; testinput1/1787: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1787"
  "(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:multiple-lines t :single-line nil)
  (list
    "B"
    "B" ) )

;;;; testinput1/1790: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1790"
  "(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:single-line t)
  (list
    (backslash "abcde\\n1234X")
    (backslash "abcde\\n1234X") ) )

;;;; testinput1/1791: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1791"
  "(.*X|^B)"
  "BarFoo"
  '(:single-line t)
  (list
    "B"
    "B" ) )

;;;; testinput1/1792: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1792"
  "(.*X|^B)"
  "*** Failers"
  '(:single-line t)
  nil
 )

;;;; testinput1/1793: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1793"
  "(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:single-line t)
  nil
 )

;;;; testinput1/1796: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1796"
  "(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:multiple-lines t :single-line t)
  (list
    (backslash "abcde\\n1234X")
    (backslash "abcde\\n1234X") ) )

;;;; testinput1/1797: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1797"
  "(.*X|^B)"
  "BarFoo"
  '(:multiple-lines t :single-line t)
  (list
    "B"
    "B" ) )

;;;; testinput1/1798: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1798"
  "(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:multiple-lines t :single-line t)
  (list
    "B"
    "B" ) )

;;;; testinput1/1801: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1801"
  "(?s)(.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:single-line nil)
  (list
    (backslash "abcde\\n1234X")
    (backslash "abcde\\n1234X") ) )

;;;; testinput1/1802: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1802"
  "(?s)(.*X|^B)"
  "BarFoo"
  '(:single-line nil)
  (list
    "B"
    "B" ) )

;;;; testinput1/1803: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1803"
  "(?s)(.*X|^B)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1804: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1804"
  "(?s)(.*X|^B)"
  (backslash "abcde\\nBar")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1807: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1807"
  "(?s:.*X|^B)"
  (backslash "abcde\\n1234Xyz")
  '(:single-line nil)
  (list (backslash "abcde\\n1234X")) )

;;;; testinput1/1808: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1808"
  "(?s:.*X|^B)"
  "BarFoo"
  '(:single-line nil)
  (list "B") )

;;;; testinput1/1809: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1809"
  "(?s:.*X|^B)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1810: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1810"
  "(?s:.*X|^B)"
  (backslash "abcde\\nBar")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1813: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1813"
  "^.*B"
  "**** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1814: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1814"
  "^.*B"
  (backslash "abc\\nB")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1817: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1817"
  "(?s)^.*B"
  (backslash "abc\\nB")
  '(:single-line nil)
  (list (backslash "abc\\nB")) )

;;;; testinput1/1820: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1820"
  "(?m)^.*B"
  (backslash "abc\\nB")
  '(:single-line nil)
  (list "B") )

;;;; testinput1/1823: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1823"
  "(?ms)^.*B"
  (backslash "abc\\nB")
  '(:single-line nil)
  (list (backslash "abc\\nB")) )

;;;; testinput1/1826: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1826"
  "(?ms)^B"
  (backslash "abc\\nB")
  '(:single-line nil)
  (list "B") )

;;;; testinput1/1829: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1829"
  "(?s)B$"
  "B
"
  '(:single-line nil)
  (list "B") )

;;;; testinput1/1832: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1832"
  "^[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]"
  "123456654321"
  '(:single-line nil)
  (list "123456654321") )

;;;; testinput1/1835: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1835"
  "^\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d\\d"
  "123456654321"
  '(:single-line nil)
  (list "123456654321") )

;;;; testinput1/1838: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1838"
  "^[\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d][\\d]"
  "123456654321"
  '(:single-line nil)
  (list "123456654321") )

;;;; testinput1/1841: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1841"
  "^[abc]{12}"
  "abcabcabcabc"
  '(:single-line nil)
  (list "abcabcabcabc") )

;;;; testinput1/1844: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1844"
  "^[a-c]{12}"
  "abcabcabcabc"
  '(:single-line nil)
  (list "abcabcabcabc") )

;;;; testinput1/1847: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1847"
  "^(a|b|c){12}"
  "abcabcabcabc"
  '(:single-line nil)
  (list
    "abcabcabcabc"
    "c" ) )

;;;; testinput1/1850: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1850"
  "^[abcdefghijklmnopqrstuvwxy0123456789]"
  "n"
  '(:single-line nil)
  (list "n") )

;;;; testinput1/1851: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1851"
  "^[abcdefghijklmnopqrstuvwxy0123456789]"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1852: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1852"
  "^[abcdefghijklmnopqrstuvwxy0123456789]"
  "z"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1855: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1855"
  "abcde{0,0}"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; testinput1/1856: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1856"
  "abcde{0,0}"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1857: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1857"
  "abcde{0,0}"
  "abce"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1860: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1860"
  "ab[cd]{0,0}e"
  "abe"
  '(:single-line nil)
  (list "abe") )

;;;; testinput1/1861: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1861"
  "ab[cd]{0,0}e"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1862: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1862"
  "ab[cd]{0,0}e"
  "abcde"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1865: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1865"
  "ab(c){0,0}d"
  "abd"
  '(:single-line nil)
  (list
    "abd"
    nil ) )

;;;; testinput1/1866: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1866"
  "ab(c){0,0}d"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1867: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1867"
  "ab(c){0,0}d"
  "abcd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1870: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1870"
  "a(b*)"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput1/1871: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1871"
  "a(b*)"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput1/1872: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1872"
  "a(b*)"
  "abbbb"
  '(:single-line nil)
  (list
    "abbbb"
    "bbbb" ) )

;;;; testinput1/1873: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1873"
  "a(b*)"
  "*** Failers"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput1/1874: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1874"
  "a(b*)"
  "bbbbb"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1877: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1877"
  "ab\\d{0}e"
  "abe"
  '(:single-line nil)
  (list "abe") )

;;;; testinput1/1878: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1878"
  "ab\\d{0}e"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1879: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1879"
  "ab\\d{0}e"
  "ab1e"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1882: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1882"
  "\"([^\\\\\"]+|\\\\.)*\""
  "the \"quick\" brown fox"
  '(:single-line nil)
  (list
    "\"quick\""
    "quick" ) )

;;;; testinput1/1883: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1883"
  "\"([^\\\\\"]+|\\\\.)*\""
  "\"the \\\"quick\\\" brown fox\""
  '(:single-line nil)
  (list
    "\"the \\\"quick\\\" brown fox\""
    " brown fox" ) )

;;;; testinput1/1886: 
;;;
;;;    
;
(test-case/g
  "pcre-1/1886"
  ".*?"
  "abc"
  '(:single-line nil)
  (list ""
        "a"
        ""
        "b"
        ""
        "c"
        "" )
    "" )

;;;; testinput1/1889: 
;;;
;;;    
;
(test-case/g
  "pcre-1/1889"
  "\\b"
  "abc"
  '(:single-line nil)
  (list ""
        "" )
    "" )

;;;; testinput1/1892: 
;;;
;;;    
;
(test-case/g
  "pcre-1/1892"
  "\\b"
  "abc"
  '(:single-line nil)
  (list ""
        "" )
    "" )

;;;; testinput1/1895: 
;;;
;;;    
;
(test-case/g
  "pcre-1/1895"
  "(?#)"
  "abc"
  '(:single-line nil)
  (list ""
        ""
        ""
        "" )
    "" )

;;;; testinput1/1898: 
;;;
;;;    Matched with 11 captures.
;
(test-case
  "pcre-1/1898"
  "<tr([\\w\\W\\s\\d][^<>]{0,})><TD([\\w\\W\\s\\d][^<>]{0,})>([\\d]{0,}\\.)(.*)((<BR>([\\w\\W\\s\\d][^<>]{0,})|[\\s]{0,}))</a></TD><TD([\\w\\W\\s\\d][^<>]{0,})>([\\w\\W\\s\\d][^<>]{0,})</TD><TD([\\w\\W\\s\\d][^<>]{0,})>([\\w\\W\\s\\d][^<>]{0,})</TD></TR>"
  "<TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>"
  '(:ignore-case t :single-line t)
  (list
    "<TR BGCOLOR='#DBE9E9'><TD align=left valign=top>43.<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)</a></TD><TD align=left valign=top>Lega lstaff.com</TD><TD align=left valign=top>CA - Statewide</TD></TR>"
    " BGCOLOR='#DBE9E9'"
    " align=left valign=top"
    "43."
    "<a href='joblist.cfm?JobID=94 6735&Keyword='>Word Processor<BR>(N-1286)"
    ""
    ""
    nil
    " align=left valign=top"
    "Lega lstaff.com"
    " align=left valign=top"
    "CA - Statewide" ) )

;;;; testinput1/1901: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1901"
  "a[^a]b"
  "acb"
  '(:single-line nil)
  (list "acb") )

;;;; testinput1/1902: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1902"
  "a[^a]b"
  (backslash "a\\nb")
  '(:single-line nil)
  (list (backslash "a\\nb")) )

;;;; testinput1/1905: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1905"
  "a.b"
  "acb"
  '(:single-line nil)
  (list "acb") )

;;;; testinput1/1906: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1906"
  "a.b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1907: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1907"
  "a.b"
  (backslash "a\\nb")
  '(:single-line nil)
  nil
 )

;;;; testinput1/1910: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1910"
  "a[^a]b"
  "acb"
  '(:single-line t)
  (list "acb") )

;;;; testinput1/1911: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1911"
  "a[^a]b"
  (backslash "a\\nb")
  '(:single-line t)
  (list (backslash "a\\nb")) )

;;;; testinput1/1914: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1914"
  "a.b"
  "acb"
  '(:single-line t)
  (list "acb") )

;;;; testinput1/1915: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1915"
  "a.b"
  (backslash "a\\nb")
  '(:single-line t)
  (list (backslash "a\\nb")) )

;;;; testinput1/1918: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1918"
  "^(b+?|a){1,2}?c"
  "bac"
  '(:single-line nil)
  (list
    "bac"
    "a" ) )

;;;; testinput1/1919: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1919"
  "^(b+?|a){1,2}?c"
  "bbac"
  '(:single-line nil)
  (list
    "bbac"
    "a" ) )

;;;; testinput1/1920: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1920"
  "^(b+?|a){1,2}?c"
  "bbbac"
  '(:single-line nil)
  (list
    "bbbac"
    "a" ) )

;;;; testinput1/1921: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1921"
  "^(b+?|a){1,2}?c"
  "bbbbac"
  '(:single-line nil)
  (list
    "bbbbac"
    "a" ) )

;;;; testinput1/1922: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1922"
  "^(b+?|a){1,2}?c"
  "bbbbbac"
  '(:single-line nil)
  (list
    "bbbbbac"
    "a" ) )

;;;; testinput1/1925: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1925"
  "^(b+|a){1,2}?c"
  "bac"
  '(:single-line nil)
  (list
    "bac"
    "a" ) )

;;;; testinput1/1926: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1926"
  "^(b+|a){1,2}?c"
  "bbac"
  '(:single-line nil)
  (list
    "bbac"
    "a" ) )

;;;; testinput1/1927: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1927"
  "^(b+|a){1,2}?c"
  "bbbac"
  '(:single-line nil)
  (list
    "bbbac"
    "a" ) )

;;;; testinput1/1928: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1928"
  "^(b+|a){1,2}?c"
  "bbbbac"
  '(:single-line nil)
  (list
    "bbbbac"
    "a" ) )

;;;; testinput1/1929: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1929"
  "^(b+|a){1,2}?c"
  "bbbbbac"
  '(:single-line nil)
  (list
    "bbbbbac"
    "a" ) )

;;;; testinput1/1932: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1932"
  "(?!\\A)x"
  (backslash "x\\nb\\n")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1933: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1933"
  "(?!\\A)x"
  (backslash "a\\u0008x\\n")
  '(:multiple-lines t :single-line nil)
  (list "x") )

;;;; testinput1/1936: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1936"
  "\\x00{ab}"
  (backslash "\\u0000{ab}")
  '(:single-line nil)
  (list (backslash "\\u0000{ab}")) )

;;;; testinput1/1939: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1939"
  "(A|B)*?CD"
  "CD"
  '(:single-line nil)
  (list
    "CD"
    nil ) )

;;;; testinput1/1942: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1942"
  "(A|B)*CD"
  "CD"
  '(:single-line nil)
  (list
    "CD"
    nil ) )

;;;; testinput1/1945: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1945"
  "(AB)*?\\1"
  "ABABAB"
  '(:single-line nil)
  (list
    "ABAB"
    "AB" ) )

;;;; testinput1/1948: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1948"
  "(AB)*\\1"
  "ABABAB"
  '(:single-line nil)
  (list
    "ABABAB"
    "AB" ) )

;;;; testinput1/1951: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1951"
  "(?<!bar)foo"
  "foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/1952: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1952"
  "(?<!bar)foo"
  "catfood"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/1953: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1953"
  "(?<!bar)foo"
  "arfootle"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/1954: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1954"
  "(?<!bar)foo"
  "rfoosh"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/1955: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1955"
  "(?<!bar)foo"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1956: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1956"
  "(?<!bar)foo"
  "barfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1957: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1957"
  "(?<!bar)foo"
  "towbarfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1960: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1960"
  "\\w{3}(?<!bar)foo"
  "catfood"
  '(:single-line nil)
  (list "catfoo") )

;;;; testinput1/1961: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1961"
  "\\w{3}(?<!bar)foo"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1962: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1962"
  "\\w{3}(?<!bar)foo"
  "foo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1963: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1963"
  "\\w{3}(?<!bar)foo"
  "barfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1964: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1964"
  "\\w{3}(?<!bar)foo"
  "towbarfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1967: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1967"
  "(?<=(foo)a)bar"
  "fooabar"
  '(:single-line nil)
  (list
    "bar"
    "foo" ) )

;;;; testinput1/1968: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1968"
  "(?<=(foo)a)bar"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1969: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1969"
  "(?<=(foo)a)bar"
  "bar"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1970: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1970"
  "(?<=(foo)a)bar"
  "foobbar"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1973: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1973"
  "\\Aabc\\z"
  "abc"
  '(:multiple-lines t :single-line nil)
  (list "abc") )

;;;; testinput1/1974: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1974"
  "\\Aabc\\z"
  "*** Failers"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1975: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1975"
  "\\Aabc\\z"
  "abc
"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1976: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1976"
  "\\Aabc\\z"
  (backslash "qqq\\nabc")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1977: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1977"
  "\\Aabc\\z"
  (backslash "abc\\nzzz")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1978: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1978"
  "\\Aabc\\z"
  (backslash "qqq\\nabc\\nzzz")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/1981: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1981"
  "(?>.*/)foo"
  "/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/it/you/see/"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1984: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/1984"
  "(?>.*/)foo"
  "/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo"
  '(:single-line nil)
  (list "/this/is/a/very/long/line/in/deed/with/very/many/slashes/in/and/foo") )

;;;; testinput1/1987: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1987"
  "(?>(\\.\\d\\d[1-9]?))\\d+"
  "1.230003938"
  '(:single-line nil)
  (list
    ".230003938"
    ".23" ) )

;;;; testinput1/1988: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1988"
  "(?>(\\.\\d\\d[1-9]?))\\d+"
  "1.875000282"
  '(:single-line nil)
  (list
    ".875000282"
    ".875" ) )

;;;; testinput1/1989: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1989"
  "(?>(\\.\\d\\d[1-9]?))\\d+"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1990: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1990"
  "(?>(\\.\\d\\d[1-9]?))\\d+"
  "1.235"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1993: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/1993"
  "^((?>\\w+)|(?>\\s+))*$"
  "now is the time for all good men to come to the aid of the party"
  '(:single-line nil)
  (list
    "now is the time for all good men to come to the aid of the party"
    "party" ) )

;;;; testinput1/1994: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1994"
  "^((?>\\w+)|(?>\\s+))*$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1995: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/1995"
  "^((?>\\w+)|(?>\\s+))*$"
  "this is not a line with only words and spaces!"
  '(:single-line nil)
  nil
 )

;;;; testinput1/1998: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1998"
  "(\\d+)(\\w)"
  "12345a"
  '(:single-line nil)
  (list
    "12345a"
    "12345"
    "a" ) )

;;;; testinput1/1999: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/1999"
  "(\\d+)(\\w)"
  "12345+"
  '(:single-line nil)
  (list
    "12345"
    "1234"
    "5" ) )

;;;; testinput1/2002: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2002"
  "((?>\\d+))(\\w)"
  "12345a"
  '(:single-line nil)
  (list
    "12345a"
    "12345"
    "a" ) )

;;;; testinput1/2003: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2003"
  "((?>\\d+))(\\w)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2004: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2004"
  "((?>\\d+))(\\w)"
  "12345+"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2007: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2007"
  "(?>a+)b"
  "aaab"
  '(:single-line nil)
  (list "aaab") )

;;;; testinput1/2010: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2010"
  "((?>a+)b)"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaab" ) )

;;;; testinput1/2013: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2013"
  "(?>(a+))b"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaa" ) )

;;;; testinput1/2016: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2016"
  "(?>b)+"
  "aaabbbccc"
  '(:single-line nil)
  (list "bbb") )

;;;; testinput1/2019: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2019"
  "(?>a+|b+|c+)*c"
  "aaabbbbccccd"
  '(:single-line nil)
  (list "aaabbbbc") )

;;;; testinput1/2022: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2022"
  "((?>[^()]+)|\\([^()]*\\))+"
  "((abc(ade)ufh()()x"
  '(:single-line nil)
  (list
    "abc(ade)ufh()()x"
    "x" ) )

;;;; testinput1/2025: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2025"
  "\\(((?>[^()]+)|\\([^()]+\\))+\\)"
  "(abc)"
  '(:single-line nil)
  (list
    "(abc)"
    "abc" ) )

;;;; testinput1/2026: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2026"
  "\\(((?>[^()]+)|\\([^()]+\\))+\\)"
  "(abc(def)xyz)"
  '(:single-line nil)
  (list
    "(abc(def)xyz)"
    "xyz" ) )

;;;; testinput1/2027: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2027"
  "\\(((?>[^()]+)|\\([^()]+\\))+\\)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2028: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2028"
  "\\(((?>[^()]+)|\\([^()]+\\))+\\)"
  "((()aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2031: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2031"
  "a(?-i)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list "ab") )

;;;; testinput1/2032: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2032"
  "a(?-i)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  (list "Ab") )

;;;; testinput1/2033: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2033"
  "a(?-i)b"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2034: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2034"
  "a(?-i)b"
  "aB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2035: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2035"
  "a(?-i)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2038: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2038"
  "(a (?x)b c)d e"
  "a bcd e"
  '(:single-line nil)
  (list
    "a bcd e"
    "a bc" ) )

;;;; testinput1/2039: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2039"
  "(a (?x)b c)d e"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2040: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2040"
  "(a (?x)b c)d e"
  "a b cd e"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2041: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2041"
  "(a (?x)b c)d e"
  "abcd e"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2042: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2042"
  "(a (?x)b c)d e"
  "a bcde"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2045: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2045"
  "(a b(?x)c d (?-x)e f)"
  "a bcde f"
  '(:single-line nil)
  (list
    "a bcde f"
    "a bcde f" ) )

;;;; testinput1/2046: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2046"
  "(a b(?x)c d (?-x)e f)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2047: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2047"
  "(a b(?x)c d (?-x)e f)"
  "abcdef"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2050: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2050"
  "(a(?i)b)c"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; testinput1/2051: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2051"
  "(a(?i)b)c"
  "aBc"
  '(:single-line nil)
  (list
    "aBc"
    "aB" ) )

;;;; testinput1/2052: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2052"
  "(a(?i)b)c"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2053: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2053"
  "(a(?i)b)c"
  "abC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2054: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2054"
  "(a(?i)b)c"
  "aBC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2055: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2055"
  "(a(?i)b)c"
  "Abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2056: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2056"
  "(a(?i)b)c"
  "ABc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2057: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2057"
  "(a(?i)b)c"
  "ABC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2058: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2058"
  "(a(?i)b)c"
  "AbC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2061: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2061"
  "a(?i:b)c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2062: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2062"
  "a(?i:b)c"
  "aBc"
  '(:single-line nil)
  (list "aBc") )

;;;; testinput1/2063: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2063"
  "a(?i:b)c"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2064: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2064"
  "a(?i:b)c"
  "ABC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2065: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2065"
  "a(?i:b)c"
  "abC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2066: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2066"
  "a(?i:b)c"
  "aBC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2069: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2069"
  "a(?i:b)*c"
  "aBc"
  '(:single-line nil)
  (list "aBc") )

;;;; testinput1/2070: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2070"
  "a(?i:b)*c"
  "aBBc"
  '(:single-line nil)
  (list "aBBc") )

;;;; testinput1/2071: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2071"
  "a(?i:b)*c"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2072: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2072"
  "a(?i:b)*c"
  "aBC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2073: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2073"
  "a(?i:b)*c"
  "aBBC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2076: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2076"
  "a(?=b(?i)c)\\w\\wd"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; testinput1/2077: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2077"
  "a(?=b(?i)c)\\w\\wd"
  "abCd"
  '(:single-line nil)
  (list "abCd") )

;;;; testinput1/2078: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2078"
  "a(?=b(?i)c)\\w\\wd"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2079: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2079"
  "a(?=b(?i)c)\\w\\wd"
  "aBCd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2080: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2080"
  "a(?=b(?i)c)\\w\\wd"
  "abcD"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2083: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2083"
  "(?s-i:more.*than).*million"
  "more than million"
  '(:ignore-case t :single-line nil)
  (list "more than million") )

;;;; testinput1/2084: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2084"
  "(?s-i:more.*than).*million"
  "more than MILLION"
  '(:ignore-case t :single-line nil)
  (list "more than MILLION") )

;;;; testinput1/2085: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2085"
  "(?s-i:more.*than).*million"
  (backslash "more \\n than Million")
  '(:ignore-case t :single-line nil)
  (list (backslash "more \\n than Million")) )

;;;; testinput1/2086: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2086"
  "(?s-i:more.*than).*million"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2087: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2087"
  "(?s-i:more.*than).*million"
  "MORE THAN MILLION"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2088: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2088"
  "(?s-i:more.*than).*million"
  (backslash "more \\n than \\n million")
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2091: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2091"
  "(?:(?s-i)more.*than).*million"
  "more than million"
  '(:ignore-case t :single-line nil)
  (list "more than million") )

;;;; testinput1/2092: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2092"
  "(?:(?s-i)more.*than).*million"
  "more than MILLION"
  '(:ignore-case t :single-line nil)
  (list "more than MILLION") )

;;;; testinput1/2093: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2093"
  "(?:(?s-i)more.*than).*million"
  (backslash "more \\n than Million")
  '(:ignore-case t :single-line nil)
  (list (backslash "more \\n than Million")) )

;;;; testinput1/2094: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2094"
  "(?:(?s-i)more.*than).*million"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2095: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2095"
  "(?:(?s-i)more.*than).*million"
  "MORE THAN MILLION"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2096: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2096"
  "(?:(?s-i)more.*than).*million"
  (backslash "more \\n than \\n million")
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2099: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2099"
  "(?>a(?i)b+)+c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2100: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2100"
  "(?>a(?i)b+)+c"
  "aBbc"
  '(:single-line nil)
  (list "aBbc") )

;;;; testinput1/2101: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2101"
  "(?>a(?i)b+)+c"
  "aBBc"
  '(:single-line nil)
  (list "aBBc") )

;;;; testinput1/2102: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2102"
  "(?>a(?i)b+)+c"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2103: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2103"
  "(?>a(?i)b+)+c"
  "Abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2104: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2104"
  "(?>a(?i)b+)+c"
  "abAb"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2105: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2105"
  "(?>a(?i)b+)+c"
  "abbC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2108: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2108"
  "(?=a(?i)b)\\w\\wc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2109: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2109"
  "(?=a(?i)b)\\w\\wc"
  "aBc"
  '(:single-line nil)
  (list "aBc") )

;;;; testinput1/2110: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2110"
  "(?=a(?i)b)\\w\\wc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2111: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2111"
  "(?=a(?i)b)\\w\\wc"
  "Ab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2112: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2112"
  "(?=a(?i)b)\\w\\wc"
  "abC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2113: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2113"
  "(?=a(?i)b)\\w\\wc"
  "aBC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2116: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2116"
  "(?<=a(?i)b)(\\w\\w)c"
  "abxxc"
  '(:single-line nil)
  (list
    "xxc"
    "xx" ) )

;;;; testinput1/2117: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2117"
  "(?<=a(?i)b)(\\w\\w)c"
  "aBxxc"
  '(:single-line nil)
  (list
    "xxc"
    "xx" ) )

;;;; testinput1/2118: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2118"
  "(?<=a(?i)b)(\\w\\w)c"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2119: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2119"
  "(?<=a(?i)b)(\\w\\w)c"
  "Abxxc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2120: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2120"
  "(?<=a(?i)b)(\\w\\w)c"
  "ABxxc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2121: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2121"
  "(?<=a(?i)b)(\\w\\w)c"
  "abxxC"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2124: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2124"
  "(?:(a)|b)(?(1)A|B)"
  "aA"
  '(:single-line nil)
  (list
    "aA"
    "a" ) )

;;;; testinput1/2125: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2125"
  "(?:(a)|b)(?(1)A|B)"
  "bB"
  '(:single-line nil)
  (list "bB") )

;;;; testinput1/2126: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2126"
  "(?:(a)|b)(?(1)A|B)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2127: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2127"
  "(?:(a)|b)(?(1)A|B)"
  "aB"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2128: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2128"
  "(?:(a)|b)(?(1)A|B)"
  "bA"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2131: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2131"
  "^(a)?(?(1)a|b)+$"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "a" ) )

;;;; testinput1/2132: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2132"
  "^(a)?(?(1)a|b)+$"
  "b"
  '(:single-line nil)
  (list
    "b"
    nil ) )

;;;; testinput1/2133: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2133"
  "^(a)?(?(1)a|b)+$"
  "bb"
  '(:single-line nil)
  (list
    "bb"
    nil ) )

;;;; testinput1/2134: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2134"
  "^(a)?(?(1)a|b)+$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2135: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2135"
  "^(a)?(?(1)a|b)+$"
  "ab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2138: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2138"
  "^(?(?=abc)\\w{3}:|\\d\\d)$"
  "abc:"
  '(:single-line nil)
  (list "abc:") )

;;;; testinput1/2139: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2139"
  "^(?(?=abc)\\w{3}:|\\d\\d)$"
  "12"
  '(:single-line nil)
  (list "12") )

;;;; testinput1/2140: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2140"
  "^(?(?=abc)\\w{3}:|\\d\\d)$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2141: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2141"
  "^(?(?=abc)\\w{3}:|\\d\\d)$"
  "123"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2142: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2142"
  "^(?(?=abc)\\w{3}:|\\d\\d)$"
  "xyz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2145: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2145"
  "^(?(?!abc)\\d\\d|\\w{3}:)$"
  "abc:"
  '(:single-line nil)
  (list "abc:") )

;;;; testinput1/2146: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2146"
  "^(?(?!abc)\\d\\d|\\w{3}:)$"
  "12"
  '(:single-line nil)
  (list "12") )

;;;; testinput1/2147: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2147"
  "^(?(?!abc)\\d\\d|\\w{3}:)$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2148: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2148"
  "^(?(?!abc)\\d\\d|\\w{3}:)$"
  "123"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2149: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2149"
  "^(?(?!abc)\\d\\d|\\w{3}:)$"
  "xyz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2152: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2152"
  "(?(?<=foo)bar|cat)"
  "foobar"
  '(:single-line nil)
  (list "bar") )

;;;; testinput1/2153: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2153"
  "(?(?<=foo)bar|cat)"
  "cat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput1/2154: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2154"
  "(?(?<=foo)bar|cat)"
  "fcat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput1/2155: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2155"
  "(?(?<=foo)bar|cat)"
  "focat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput1/2156: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2156"
  "(?(?<=foo)bar|cat)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2157: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2157"
  "(?(?<=foo)bar|cat)"
  "foocat"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2160: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2160"
  "(?(?<!foo)cat|bar)"
  "foobar"
  '(:single-line nil)
  (list "bar") )

;;;; testinput1/2161: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2161"
  "(?(?<!foo)cat|bar)"
  "cat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput1/2162: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2162"
  "(?(?<!foo)cat|bar)"
  "fcat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput1/2163: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2163"
  "(?(?<!foo)cat|bar)"
  "focat"
  '(:single-line nil)
  (list "cat") )

;;;; testinput1/2164: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2164"
  "(?(?<!foo)cat|bar)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2165: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2165"
  "(?(?<!foo)cat|bar)"
  "foocat"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2168: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2168"
  "( \\( )? [^()]+ (?(1) \\) |) "
  "abcd"
  '(:extended-syntax t :single-line nil)
  (list
    "abcd"
    nil ) )

;;;; testinput1/2169: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2169"
  "( \\( )? [^()]+ (?(1) \\) |) "
  "(abcd)"
  '(:extended-syntax t :single-line nil)
  (list
    "(abcd)"
    "(" ) )

;;;; testinput1/2170: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2170"
  "( \\( )? [^()]+ (?(1) \\) |) "
  "the quick (abcd) fox"
  '(:extended-syntax t :single-line nil)
  (list
    "the quick "
    nil ) )

;;;; testinput1/2171: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2171"
  "( \\( )? [^()]+ (?(1) \\) |) "
  "(abcd"
  '(:extended-syntax t :single-line nil)
  (list
    "abcd"
    nil ) )

;;;; testinput1/2174: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2174"
  "( \\( )? [^()]+ (?(1) \\) ) "
  "abcd"
  '(:extended-syntax t :single-line nil)
  (list
    "abcd"
    nil ) )

;;;; testinput1/2175: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2175"
  "( \\( )? [^()]+ (?(1) \\) ) "
  "(abcd)"
  '(:extended-syntax t :single-line nil)
  (list
    "(abcd)"
    "(" ) )

;;;; testinput1/2176: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2176"
  "( \\( )? [^()]+ (?(1) \\) ) "
  "the quick (abcd) fox"
  '(:extended-syntax t :single-line nil)
  (list
    "the quick "
    nil ) )

;;;; testinput1/2177: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2177"
  "( \\( )? [^()]+ (?(1) \\) ) "
  "(abcd"
  '(:extended-syntax t :single-line nil)
  (list
    "abcd"
    nil ) )

;;;; testinput1/2180: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2180"
  "^(?(2)a|(1)(2))+$"
  "12"
  '(:single-line nil)
  (list
    "12"
    "1"
    "2" ) )

;;;; testinput1/2181: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2181"
  "^(?(2)a|(1)(2))+$"
  "12a"
  '(:single-line nil)
  (list
    "12a"
    "1"
    "2" ) )

;;;; testinput1/2182: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2182"
  "^(?(2)a|(1)(2))+$"
  "12aa"
  '(:single-line nil)
  (list
    "12aa"
    "1"
    "2" ) )

;;;; testinput1/2183: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2183"
  "^(?(2)a|(1)(2))+$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2184: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2184"
  "^(?(2)a|(1)(2))+$"
  "1234"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2187: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2187"
  "((?i)blah)\\s+\\1"
  "blah blah"
  '(:single-line nil)
  (list
    "blah blah"
    "blah" ) )

;;;; testinput1/2188: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2188"
  "((?i)blah)\\s+\\1"
  "BLAH BLAH"
  '(:single-line nil)
  (list
    "BLAH BLAH"
    "BLAH" ) )

;;;; testinput1/2189: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2189"
  "((?i)blah)\\s+\\1"
  "Blah Blah"
  '(:single-line nil)
  (list
    "Blah Blah"
    "Blah" ) )

;;;; testinput1/2190: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2190"
  "((?i)blah)\\s+\\1"
  "blaH blaH"
  '(:single-line nil)
  (list
    "blaH blaH"
    "blaH" ) )

;;;; testinput1/2191: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2191"
  "((?i)blah)\\s+\\1"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2192: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2192"
  "((?i)blah)\\s+\\1"
  "blah BLAH"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2193: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2193"
  "((?i)blah)\\s+\\1"
  "Blah blah"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2194: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2194"
  "((?i)blah)\\s+\\1"
  "blaH blah"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2197: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2197"
  "((?i)blah)\\s+(?i:\\1)"
  "blah blah"
  '(:single-line nil)
  (list
    "blah blah"
    "blah" ) )

;;;; testinput1/2198: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2198"
  "((?i)blah)\\s+(?i:\\1)"
  "BLAH BLAH"
  '(:single-line nil)
  (list
    "BLAH BLAH"
    "BLAH" ) )

;;;; testinput1/2199: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2199"
  "((?i)blah)\\s+(?i:\\1)"
  "Blah Blah"
  '(:single-line nil)
  (list
    "Blah Blah"
    "Blah" ) )

;;;; testinput1/2200: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2200"
  "((?i)blah)\\s+(?i:\\1)"
  "blaH blaH"
  '(:single-line nil)
  (list
    "blaH blaH"
    "blaH" ) )

;;;; testinput1/2201: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2201"
  "((?i)blah)\\s+(?i:\\1)"
  "blah BLAH"
  '(:single-line nil)
  (list
    "blah BLAH"
    "blah" ) )

;;;; testinput1/2202: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2202"
  "((?i)blah)\\s+(?i:\\1)"
  "Blah blah"
  '(:single-line nil)
  (list
    "Blah blah"
    "Blah" ) )

;;;; testinput1/2203: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2203"
  "((?i)blah)\\s+(?i:\\1)"
  "blaH blah"
  '(:single-line nil)
  (list
    "blaH blah"
    "blaH" ) )

;;;; testinput1/2206: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2206"
  "(?>a*)*"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2207: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2207"
  "(?>a*)*"
  "aa"
  '(:single-line nil)
  (list "aa") )

;;;; testinput1/2208: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2208"
  "(?>a*)*"
  "aaaa"
  '(:single-line nil)
  (list "aaaa") )

;;;; testinput1/2211: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2211"
  "(abc|)+"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "" ) )

;;;; testinput1/2212: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2212"
  "(abc|)+"
  "abcabc"
  '(:single-line nil)
  (list
    "abcabc"
    "" ) )

;;;; testinput1/2213: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2213"
  "(abc|)+"
  "abcabcabc"
  '(:single-line nil)
  (list
    "abcabcabc"
    "" ) )

;;;; testinput1/2214: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2214"
  "(abc|)+"
  "xyz"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2217: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2217"
  "([a]*)*"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput1/2218: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2218"
  "([a]*)*"
  "aaaaa"
  '(:single-line nil)
  (list
    "aaaaa"
    "" ) )

;;;; testinput1/2221: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2221"
  "([ab]*)*"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput1/2222: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2222"
  "([ab]*)*"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput1/2223: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2223"
  "([ab]*)*"
  "ababab"
  '(:single-line nil)
  (list
    "ababab"
    "" ) )

;;;; testinput1/2224: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2224"
  "([ab]*)*"
  "aaaabcde"
  '(:single-line nil)
  (list
    "aaaab"
    "" ) )

;;;; testinput1/2225: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2225"
  "([ab]*)*"
  "bbbb"
  '(:single-line nil)
  (list
    "bbbb"
    "" ) )

;;;; testinput1/2228: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2228"
  "([^a]*)*"
  "b"
  '(:single-line nil)
  (list
    "b"
    "" ) )

;;;; testinput1/2229: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2229"
  "([^a]*)*"
  "bbbb"
  '(:single-line nil)
  (list
    "bbbb"
    "" ) )

;;;; testinput1/2230: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2230"
  "([^a]*)*"
  "aaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2233: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2233"
  "([^ab]*)*"
  "cccc"
  '(:single-line nil)
  (list
    "cccc"
    "" ) )

;;;; testinput1/2234: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2234"
  "([^ab]*)*"
  "abab"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2237: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2237"
  "([a]*?)*"
  "a"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2238: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2238"
  "([a]*?)*"
  "aaaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2241: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2241"
  "([ab]*?)*"
  "a"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2242: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2242"
  "([ab]*?)*"
  "b"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2243: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2243"
  "([ab]*?)*"
  "abab"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2244: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2244"
  "([ab]*?)*"
  "baba"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2247: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2247"
  "([^a]*?)*"
  "b"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2248: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2248"
  "([^a]*?)*"
  "bbbb"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2249: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2249"
  "([^a]*?)*"
  "aaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2252: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2252"
  "([^ab]*?)*"
  "c"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2253: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2253"
  "([^ab]*?)*"
  "cccc"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2254: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2254"
  "([^ab]*?)*"
  "baba"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2257: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2257"
  "(?>a*)*"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2258: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2258"
  "(?>a*)*"
  "aaabcde"
  '(:single-line nil)
  (list "aaa") )

;;;; testinput1/2261: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2261"
  "((?>a*))*"
  "aaaaa"
  '(:single-line nil)
  (list
    "aaaaa"
    "" ) )

;;;; testinput1/2262: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2262"
  "((?>a*))*"
  "aabbaa"
  '(:single-line nil)
  (list
    "aa"
    "" ) )

;;;; testinput1/2265: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2265"
  "((?>a*?))*"
  "aaaaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2266: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2266"
  "((?>a*?))*"
  "aabbaa"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/2269: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2269"
  "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) "
  "12-sep-98"
  '(:extended-syntax t :single-line nil)
  (list "12-sep-98") )

;;;; testinput1/2270: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2270"
  "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) "
  "12-09-98"
  '(:extended-syntax t :single-line nil)
  (list "12-09-98") )

;;;; testinput1/2271: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2271"
  "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) "
  "*** Failers"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/2272: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2272"
  "(?(?=[^a-z]+[a-z])  \\d{2}-[a-z]{3}-\\d{2}  |  \\d{2}-\\d{2}-\\d{2} ) "
  "sep-12-98"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/2275: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2275"
  "(?<=(foo))bar\\1"
  "foobarfoo"
  '(:single-line nil)
  (list
    "barfoo"
    "foo" ) )

;;;; testinput1/2276: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2276"
  "(?<=(foo))bar\\1"
  "foobarfootling"
  '(:single-line nil)
  (list
    "barfoo"
    "foo" ) )

;;;; testinput1/2277: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2277"
  "(?<=(foo))bar\\1"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2278: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2278"
  "(?<=(foo))bar\\1"
  "foobar"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2279: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2279"
  "(?<=(foo))bar\\1"
  "barfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2282: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2282"
  "(?i:saturday|sunday)"
  "saturday"
  '(:single-line nil)
  (list "saturday") )

;;;; testinput1/2283: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2283"
  "(?i:saturday|sunday)"
  "sunday"
  '(:single-line nil)
  (list "sunday") )

;;;; testinput1/2284: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2284"
  "(?i:saturday|sunday)"
  "Saturday"
  '(:single-line nil)
  (list "Saturday") )

;;;; testinput1/2285: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2285"
  "(?i:saturday|sunday)"
  "Sunday"
  '(:single-line nil)
  (list "Sunday") )

;;;; testinput1/2286: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2286"
  "(?i:saturday|sunday)"
  "SATURDAY"
  '(:single-line nil)
  (list "SATURDAY") )

;;;; testinput1/2287: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2287"
  "(?i:saturday|sunday)"
  "SUNDAY"
  '(:single-line nil)
  (list "SUNDAY") )

;;;; testinput1/2288: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2288"
  "(?i:saturday|sunday)"
  "SunDay"
  '(:single-line nil)
  (list "SunDay") )

;;;; testinput1/2291: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2291"
  "(a(?i)bc|BB)x"
  "abcx"
  '(:single-line nil)
  (list
    "abcx"
    "abc" ) )

;;;; testinput1/2292: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2292"
  "(a(?i)bc|BB)x"
  "aBCx"
  '(:single-line nil)
  (list
    "aBCx"
    "aBC" ) )

;;;; testinput1/2293: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2293"
  "(a(?i)bc|BB)x"
  "bbx"
  '(:single-line nil)
  (list
    "bbx"
    "bb" ) )

;;;; testinput1/2294: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2294"
  "(a(?i)bc|BB)x"
  "BBx"
  '(:single-line nil)
  (list
    "BBx"
    "BB" ) )

;;;; testinput1/2295: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2295"
  "(a(?i)bc|BB)x"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2296: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2296"
  "(a(?i)bc|BB)x"
  "abcX"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2297: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2297"
  "(a(?i)bc|BB)x"
  "aBCX"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2298: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2298"
  "(a(?i)bc|BB)x"
  "bbX"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2299: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2299"
  "(a(?i)bc|BB)x"
  "BBX"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2302: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2302"
  "^([ab](?i)[cd]|[ef])"
  "ac"
  '(:single-line nil)
  (list
    "ac"
    "ac" ) )

;;;; testinput1/2303: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2303"
  "^([ab](?i)[cd]|[ef])"
  "aC"
  '(:single-line nil)
  (list
    "aC"
    "aC" ) )

;;;; testinput1/2304: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2304"
  "^([ab](?i)[cd]|[ef])"
  "bD"
  '(:single-line nil)
  (list
    "bD"
    "bD" ) )

;;;; testinput1/2305: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2305"
  "^([ab](?i)[cd]|[ef])"
  "elephant"
  '(:single-line nil)
  (list
    "e"
    "e" ) )

;;;; testinput1/2306: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2306"
  "^([ab](?i)[cd]|[ef])"
  "Europe"
  '(:single-line nil)
  (list
    "E"
    "E" ) )

;;;; testinput1/2307: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2307"
  "^([ab](?i)[cd]|[ef])"
  "frog"
  '(:single-line nil)
  (list
    "f"
    "f" ) )

;;;; testinput1/2308: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2308"
  "^([ab](?i)[cd]|[ef])"
  "France"
  '(:single-line nil)
  (list
    "F"
    "F" ) )

;;;; testinput1/2309: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2309"
  "^([ab](?i)[cd]|[ef])"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2310: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2310"
  "^([ab](?i)[cd]|[ef])"
  "Africa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2313: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2313"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "ab" ) )

;;;; testinput1/2314: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2314"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "aBd"
  '(:single-line nil)
  (list
    "aBd"
    "aBd" ) )

;;;; testinput1/2315: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2315"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "xy"
  '(:single-line nil)
  (list
    "xy"
    "xy" ) )

;;;; testinput1/2316: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2316"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "xY"
  '(:single-line nil)
  (list
    "xY"
    "xY" ) )

;;;; testinput1/2317: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2317"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "zebra"
  '(:single-line nil)
  (list
    "z"
    "z" ) )

;;;; testinput1/2318: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2318"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "Zambesi"
  '(:single-line nil)
  (list
    "Z"
    "Z" ) )

;;;; testinput1/2319: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2319"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2320: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2320"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "aCD"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2321: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2321"
  "^(ab|a(?i)[b-c](?m-i)d|x(?i)y|z)"
  "XY"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2324: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2324"
  "(?<=foo\\n)^bar"
  (backslash "foo\\nbar")
  '(:multiple-lines t :single-line nil)
  (list "bar") )

;;;; testinput1/2325: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2325"
  "(?<=foo\\n)^bar"
  "*** Failers"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/2326: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2326"
  "(?<=foo\\n)^bar"
  "bar"
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/2327: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2327"
  "(?<=foo\\n)^bar"
  (backslash "baz\\nbar")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/2330: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2330"
  "(?<=(?<!foo)bar)baz"
  "barbaz"
  '(:single-line nil)
  (list "baz") )

;;;; testinput1/2331: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2331"
  "(?<=(?<!foo)bar)baz"
  "barbarbaz"
  '(:single-line nil)
  (list "baz") )

;;;; testinput1/2332: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2332"
  "(?<=(?<!foo)bar)baz"
  "koobarbaz"
  '(:single-line nil)
  (list "baz") )

;;;; testinput1/2333: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2333"
  "(?<=(?<!foo)bar)baz"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2334: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2334"
  "(?<=(?<!foo)bar)baz"
  "baz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2335: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2335"
  "(?<=(?<!foo)bar)baz"
  "foobarbaz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2342: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2342"
  "^(a\\1?){4}$"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2343: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2343"
  "^(a\\1?){4}$"
  "aa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2344: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2344"
  "^(a\\1?){4}$"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2345: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2345"
  "^(a\\1?){4}$"
  "aaaa"
  '(:single-line nil)
  (list
    "aaaa"
    "a" ) )

;;;; testinput1/2346: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2346"
  "^(a\\1?){4}$"
  "aaaaa"
  '(:single-line nil)
  (list
    "aaaaa"
    "a" ) )

;;;; testinput1/2347: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2347"
  "^(a\\1?){4}$"
  "aaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaa"
    "a" ) )

;;;; testinput1/2348: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2348"
  "^(a\\1?){4}$"
  "aaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2349: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2349"
  "^(a\\1?){4}$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2350: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2350"
  "^(a\\1?){4}$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "aaaa" ) )

;;;; testinput1/2351: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2351"
  "^(a\\1?){4}$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2352: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2352"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2353: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2353"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2354: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2354"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2355: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2355"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2356: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2356"
  "^(a\\1?){4}$"
  "aaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2359: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2359"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2360: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2360"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2361: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2361"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2362: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/2362"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaa"
  '(:single-line nil)
  (list
    "aaaa"
    "a"
    "a"
    "a"
    "a" ) )

;;;; testinput1/2363: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/2363"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaa"
  '(:single-line nil)
  (list
    "aaaaa"
    "a"
    "aa"
    "a"
    "a" ) )

;;;; testinput1/2364: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/2364"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaa"
  '(:single-line nil)
  (list
    "aaaaaa"
    "a"
    "aa"
    "a"
    "aa" ) )

;;;; testinput1/2365: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/2365"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaa"
    "a"
    "aa"
    "aaa"
    "a" ) )

;;;; testinput1/2366: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2366"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2367: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2367"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2368: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/2368"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "a"
    "aa"
    "aaa"
    "aaaa" ) )

;;;; testinput1/2369: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2369"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2370: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2370"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2371: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2371"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2372: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2372"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2373: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2373"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2374: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2374"
  "^(a\\1?)(a\\1?)(a\\2?)(a\\3?)$"
  "aaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2380: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2380"
  "abc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2381: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2381"
  "abc"
  "xabcy"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2382: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2382"
  "abc"
  "ababc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2383: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2383"
  "abc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2384: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2384"
  "abc"
  "xbc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2385: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2385"
  "abc"
  "axc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2386: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2386"
  "abc"
  "abx"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2389: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2389"
  "ab*c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2392: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2392"
  "ab*bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2393: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2393"
  "ab*bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; testinput1/2394: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2394"
  "ab*bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput1/2397: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2397"
  ".{1}"
  "abbbbc"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2400: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2400"
  ".{3,4}"
  "abbbbc"
  '(:single-line nil)
  (list "abbb") )

;;;; testinput1/2403: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2403"
  "ab{0,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput1/2406: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2406"
  "ab+bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; testinput1/2407: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2407"
  "ab+bc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2408: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2408"
  "ab+bc"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2409: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2409"
  "ab+bc"
  "abq"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2414: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2414"
  "ab+bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput1/2417: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2417"
  "ab{1,}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput1/2420: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2420"
  "ab{1,3}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput1/2423: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2423"
  "ab{3,4}bc"
  "abbbbc"
  '(:single-line nil)
  (list "abbbbc") )

;;;; testinput1/2426: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2426"
  "ab{4,5}bc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2427: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2427"
  "ab{4,5}bc"
  "abq"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2428: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2428"
  "ab{4,5}bc"
  "abbbbc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2431: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2431"
  "ab?bc"
  "abbc"
  '(:single-line nil)
  (list "abbc") )

;;;; testinput1/2432: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2432"
  "ab?bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2435: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2435"
  "ab{0,1}bc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2440: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2440"
  "ab?c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2443: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2443"
  "ab{0,1}c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2446: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2446"
  "^abc$"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2447: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2447"
  "^abc$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2448: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2448"
  "^abc$"
  "abbbbc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2449: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2449"
  "^abc$"
  "abcc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2452: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2452"
  "^abc"
  "abcc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2457: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2457"
  "abc$"
  "aabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2458: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2458"
  "abc$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2459: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2459"
  "abc$"
  "aabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2460: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2460"
  "abc$"
  "aabcd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2463: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2463"
  "^"
  "abc"
  '(:single-line nil)
  (list "") )

;;;; testinput1/2466: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2466"
  "$"
  "abc"
  '(:single-line nil)
  (list "") )

;;;; testinput1/2469: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2469"
  "a.c"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2470: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2470"
  "a.c"
  "axc"
  '(:single-line nil)
  (list "axc") )

;;;; testinput1/2473: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2473"
  "a.*c"
  "axyzc"
  '(:single-line nil)
  (list "axyzc") )

;;;; testinput1/2476: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2476"
  "a[bc]d"
  "abd"
  '(:single-line nil)
  (list "abd") )

;;;; testinput1/2477: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2477"
  "a[bc]d"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2478: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2478"
  "a[bc]d"
  "axyzd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2479: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2479"
  "a[bc]d"
  "abc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2482: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2482"
  "a[b-d]e"
  "ace"
  '(:single-line nil)
  (list "ace") )

;;;; testinput1/2485: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2485"
  "a[b-d]"
  "aac"
  '(:single-line nil)
  (list "ac") )

;;;; testinput1/2488: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2488"
  "a[-b]"
  "a-"
  '(:single-line nil)
  (list "a-") )

;;;; testinput1/2491: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2491"
  "a[b-]"
  "a-"
  '(:single-line nil)
  (list "a-") )

;;;; testinput1/2494: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2494"
  "a]"
  "a]"
  '(:single-line nil)
  (list "a]") )

;;;; testinput1/2497: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2497"
  "a[]]b"
  "a]b"
  '(:single-line nil)
  (list "a]b") )

;;;; testinput1/2500: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2500"
  "a[^bc]d"
  "aed"
  '(:single-line nil)
  (list "aed") )

;;;; testinput1/2501: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2501"
  "a[^bc]d"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2502: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2502"
  "a[^bc]d"
  "abd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2503: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2503"
  "a[^bc]d"
  "abd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2506: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2506"
  "a[^-b]c"
  "adc"
  '(:single-line nil)
  (list "adc") )

;;;; testinput1/2509: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2509"
  "a[^]b]c"
  "adc"
  '(:single-line nil)
  (list "adc") )

;;;; testinput1/2510: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2510"
  "a[^]b]c"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2511: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2511"
  "a[^]b]c"
  "a-c"
  '(:single-line nil)
  (list "a-c") )

;;;; testinput1/2512: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2512"
  "a[^]b]c"
  "a]c"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2515: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2515"
  "\\ba\\b"
  "a-"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2516: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2516"
  "\\ba\\b"
  "-a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2517: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2517"
  "\\ba\\b"
  "-a-"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2520: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2520"
  "\\by\\b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2521: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2521"
  "\\by\\b"
  "xy"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2522: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2522"
  "\\by\\b"
  "yz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2523: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2523"
  "\\by\\b"
  "xyz"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2526: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2526"
  "\\Ba\\B"
  "*** Failers"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2527: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2527"
  "\\Ba\\B"
  "a-"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2528: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2528"
  "\\Ba\\B"
  "-a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2529: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2529"
  "\\Ba\\B"
  "-a-"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2532: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2532"
  "\\By\\b"
  "xy"
  '(:single-line nil)
  (list "y") )

;;;; testinput1/2535: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2535"
  "\\by\\B"
  "yz"
  '(:single-line nil)
  (list "y") )

;;;; testinput1/2538: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2538"
  "\\By\\B"
  "xyz"
  '(:single-line nil)
  (list "y") )

;;;; testinput1/2541: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2541"
  "\\w"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2544: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2544"
  "\\W"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/2545: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2545"
  "\\W"
  "*** Failers"
  '(:single-line nil)
  (list "*") )

;;;; testinput1/2546: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2546"
  "\\W"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/2547: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2547"
  "\\W"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2550: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2550"
  "a\\sb"
  "a b"
  '(:single-line nil)
  (list "a b") )

;;;; testinput1/2553: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2553"
  "a\\Sb"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; testinput1/2554: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2554"
  "a\\Sb"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2555: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2555"
  "a\\Sb"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; testinput1/2556: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2556"
  "a\\Sb"
  "a b"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2559: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2559"
  "\\d"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; testinput1/2562: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2562"
  "\\D"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/2563: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2563"
  "\\D"
  "*** Failers"
  '(:single-line nil)
  (list "*") )

;;;; testinput1/2564: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2564"
  "\\D"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/2565: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2565"
  "\\D"
  "1"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2568: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2568"
  "[\\w]"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2571: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2571"
  "[\\W]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/2572: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2572"
  "[\\W]"
  "*** Failers"
  '(:single-line nil)
  (list "*") )

;;;; testinput1/2573: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2573"
  "[\\W]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/2574: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2574"
  "[\\W]"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2577: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2577"
  "a[\\s]b"
  "a b"
  '(:single-line nil)
  (list "a b") )

;;;; testinput1/2580: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2580"
  "a[\\S]b"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; testinput1/2581: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2581"
  "a[\\S]b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2582: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2582"
  "a[\\S]b"
  "a-b"
  '(:single-line nil)
  (list "a-b") )

;;;; testinput1/2583: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2583"
  "a[\\S]b"
  "a b"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2586: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2586"
  "[\\d]"
  "1"
  '(:single-line nil)
  (list "1") )

;;;; testinput1/2589: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2589"
  "[\\D]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/2590: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2590"
  "[\\D]"
  "*** Failers"
  '(:single-line nil)
  (list "*") )

;;;; testinput1/2591: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2591"
  "[\\D]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/2592: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2592"
  "[\\D]"
  "1"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2595: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2595"
  "ab|cd"
  "abc"
  '(:single-line nil)
  (list "ab") )

;;;; testinput1/2596: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2596"
  "ab|cd"
  "abcd"
  '(:single-line nil)
  (list "ab") )

;;;; testinput1/2599: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2599"
  "()ef"
  "def"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; testinput1/2604: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2604"
  "a\\(b"
  "a(b"
  '(:single-line nil)
  (list "a(b") )

;;;; testinput1/2607: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2607"
  "a\\(*b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput1/2608: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2608"
  "a\\(*b"
  "a((b"
  '(:single-line nil)
  (list "a((b") )

;;;; testinput1/2611: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2611"
  "a\\\\b"
  (backslash "a\\u0008")
  '(:single-line nil)
  nil
 )

;;;; testinput1/2614: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2614"
  "((a))"
  "abc"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a" ) )

;;;; testinput1/2617: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2617"
  "(a)b(c)"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a"
    "c" ) )

;;;; testinput1/2620: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2620"
  "a+b+c"
  "aabbabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2623: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2623"
  "a{1,}b{1,}c"
  "aabbabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2626: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2626"
  "a.+?c"
  "abcabc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/2629: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2629"
  "(a+|b)*"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput1/2632: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2632"
  "(a+|b){0,}"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput1/2635: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2635"
  "(a+|b)+"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput1/2638: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2638"
  "(a+|b){1,}"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput1/2641: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2641"
  "(a+|b)?"
  "ab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/2644: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2644"
  "(a+|b){0,1}"
  "ab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/2647: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2647"
  "[^ab]*"
  "cde"
  '(:single-line nil)
  (list "cde") )

;;;; testinput1/2650: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2650"
  "abc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2651: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2651"
  "abc"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2658: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2658"
  "([abc])*d"
  "abbbcd"
  '(:single-line nil)
  (list
    "abbbcd"
    "c" ) )

;;;; testinput1/2661: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2661"
  "([abc])*bcd"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "a" ) )

;;;; testinput1/2664: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2664"
  "a|b|c|d|e"
  "e"
  '(:single-line nil)
  (list "e") )

;;;; testinput1/2667: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2667"
  "(a|b|c|d|e)f"
  "ef"
  '(:single-line nil)
  (list
    "ef"
    "e" ) )

;;;; testinput1/2670: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2670"
  "abcd*efg"
  "abcdefg"
  '(:single-line nil)
  (list "abcdefg") )

;;;; testinput1/2673: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2673"
  "ab*"
  "xabyabbbz"
  '(:single-line nil)
  (list "ab") )

;;;; testinput1/2674: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2674"
  "ab*"
  "xayabbbz"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/2677: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2677"
  "(ab|cd)e"
  "abcde"
  '(:single-line nil)
  (list
    "cde"
    "cd" ) )

;;;; testinput1/2680: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2680"
  "[abhgefdc]ij"
  "hij"
  '(:single-line nil)
  (list "hij") )

;;;; testinput1/2685: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2685"
  "(abc|)ef"
  "abcdef"
  '(:single-line nil)
  (list
    "ef"
    "" ) )

;;;; testinput1/2688: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2688"
  "(a|b)c*d"
  "abcd"
  '(:single-line nil)
  (list
    "bcd"
    "b" ) )

;;;; testinput1/2691: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2691"
  "(ab|ab*)bc"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "a" ) )

;;;; testinput1/2694: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2694"
  "a([bc]*)c*"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "bc" ) )

;;;; testinput1/2697: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2697"
  "a([bc]*)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; testinput1/2700: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2700"
  "a([bc]+)(c*d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc"
    "d" ) )

;;;; testinput1/2703: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2703"
  "a([bc]*)(c+d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "b"
    "cd" ) )

;;;; testinput1/2706: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2706"
  "a[bcd]*dcdcde"
  "adcdcde"
  '(:single-line nil)
  (list "adcdcde") )

;;;; testinput1/2709: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2709"
  "a[bcd]+dcdcde"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2710: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2710"
  "a[bcd]+dcdcde"
  "abcde"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2711: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2711"
  "a[bcd]+dcdcde"
  "adcdcde"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2714: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2714"
  "(ab|a)b*c"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "ab" ) )

;;;; testinput1/2717: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/2717"
  "((a)(b)c)(d)"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "abc"
    "a"
    "b"
    "d" ) )

;;;; testinput1/2720: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2720"
  "[a-zA-Z_][a-zA-Z0-9_]*"
  "alpha"
  '(:single-line nil)
  (list "alpha") )

;;;; testinput1/2723: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2723"
  "^a(bc+|b[eh])g|.h$"
  "abh"
  '(:single-line nil)
  (list "bh") )

;;;; testinput1/2726: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2726"
  "(bc+d$|ef*g.|h?i(j|k))"
  "effgz"
  '(:single-line nil)
  (list
    "effgz"
    "effgz" ) )

;;;; testinput1/2727: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2727"
  "(bc+d$|ef*g.|h?i(j|k))"
  "ij"
  '(:single-line nil)
  (list
    "ij"
    "ij"
    "j" ) )

;;;; testinput1/2728: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2728"
  "(bc+d$|ef*g.|h?i(j|k))"
  "reffgz"
  '(:single-line nil)
  (list
    "effgz"
    "effgz" ) )

;;;; testinput1/2729: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2729"
  "(bc+d$|ef*g.|h?i(j|k))"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2730: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2730"
  "(bc+d$|ef*g.|h?i(j|k))"
  "effg"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2731: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2731"
  "(bc+d$|ef*g.|h?i(j|k))"
  "bcdd"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2734: 
;;;
;;;    Matched with 10 captures.
;
(test-case
  "pcre-1/2734"
  "((((((((((a))))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; testinput1/2737: 
;;;
;;;    Matched with 10 captures.
;
(test-case
  "pcre-1/2737"
  "((((((((((a))))))))))\\10"
  "aa"
  '(:single-line nil)
  (list
    "aa"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; testinput1/2740: 
;;;
;;;    Matched with 9 captures.
;
(test-case
  "pcre-1/2740"
  "(((((((((a)))))))))"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a"
    "a" ) )

;;;; testinput1/2743: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2743"
  "multiple words of text"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2744: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2744"
  "multiple words of text"
  "aa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2745: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2745"
  "multiple words of text"
  "uh-uh"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2748: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2748"
  "multiple words"
  "multiple words, yeah"
  '(:single-line nil)
  (list "multiple words") )

;;;; testinput1/2751: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2751"
  "(.*)c(.*)"
  "abcde"
  '(:single-line nil)
  (list
    "abcde"
    "ab"
    "de" ) )

;;;; testinput1/2754: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2754"
  "\\((.*), (.*)\\)"
  "(a, b)"
  '(:single-line nil)
  (list
    "(a, b)"
    "a"
    "b" ) )

;;;; testinput1/2759: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2759"
  "abcd"
  "abcd"
  '(:single-line nil)
  (list "abcd") )

;;;; testinput1/2762: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2762"
  "a(bc)d"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    "bc" ) )

;;;; testinput1/2765: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2765"
  "a[-]?c"
  "ac"
  '(:single-line nil)
  (list "ac") )

;;;; testinput1/2768: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2768"
  "(abc)\\1"
  "abcabc"
  '(:single-line nil)
  (list
    "abcabc"
    "abc" ) )

;;;; testinput1/2771: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2771"
  "([a-c]*)\\1"
  "abcabc"
  '(:single-line nil)
  (list
    "abcabc"
    "abc" ) )

;;;; testinput1/2774: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2774"
  "(a)|\\1"
  "a"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/2775: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2775"
  "(a)|\\1"
  "*** Failers"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/2776: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2776"
  "(a)|\\1"
  "ab"
  '(:single-line nil)
  (list
    "a"
    "a" ) )

;;;; testinput1/2777: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2777"
  "(a)|\\1"
  "x"
  '(:single-line nil)
  nil
 )

;;;; testinput1/2780: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2780"
  "(([a-c])b*?\\2)*"
  "ababbbcbc"
  '(:single-line nil)
  (list
    "ababb"
    "bb"
    "b" ) )

;;;; testinput1/2783: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2783"
  "(([a-c])b*?\\2){3}"
  "ababbbcbc"
  '(:single-line nil)
  (list
    "ababbbcbc"
    "cbc"
    "c" ) )

;;;; testinput1/2786: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/2786"
  "((\\3|b)\\2(a)x)+"
  "aaaxabaxbaaxbbax"
  '(:single-line nil)
  (list
    "bbax"
    "bbax"
    "b"
    "a" ) )

;;;; testinput1/2789: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/2789"
  "((\\3|b)\\2(a)){2,}"
  "bbaababbabaaaaabbaaaabba"
  '(:single-line nil)
  (list
    "bbaaaabba"
    "bba"
    "b"
    "a" ) )

;;;; testinput1/2792: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2792"
  "abc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2793: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2793"
  "abc"
  "XABCY"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2794: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2794"
  "abc"
  "ABABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2795: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2795"
  "abc"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2796: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2796"
  "abc"
  "aaxabxbaxbbx"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2797: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2797"
  "abc"
  "XBC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2798: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2798"
  "abc"
  "AXC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2799: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2799"
  "abc"
  "ABX"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2802: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2802"
  "ab*c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2805: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2805"
  "ab*bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2806: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2806"
  "ab*bc"
  "ABBC"
  '(:ignore-case t :single-line nil)
  (list "ABBC") )

;;;; testinput1/2809: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2809"
  "ab*?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput1/2812: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2812"
  "ab{0,}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput1/2815: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2815"
  "ab+?bc"
  "ABBC"
  '(:ignore-case t :single-line nil)
  (list "ABBC") )

;;;; testinput1/2818: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2818"
  "ab+bc"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2819: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2819"
  "ab+bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2820: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2820"
  "ab+bc"
  "ABQ"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2825: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2825"
  "ab+bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput1/2828: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2828"
  "ab{1,}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput1/2831: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2831"
  "ab{1,3}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput1/2834: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2834"
  "ab{3,4}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  (list "ABBBBC") )

;;;; testinput1/2837: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2837"
  "ab{4,5}?bc"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2838: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2838"
  "ab{4,5}?bc"
  "ABQ"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2839: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2839"
  "ab{4,5}?bc"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2842: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2842"
  "ab??bc"
  "ABBC"
  '(:ignore-case t :single-line nil)
  (list "ABBC") )

;;;; testinput1/2843: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2843"
  "ab??bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2846: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2846"
  "ab{0,1}?bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2851: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2851"
  "ab??c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2854: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2854"
  "ab{0,1}?c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2857: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2857"
  "^abc$"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2858: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2858"
  "^abc$"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2859: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2859"
  "^abc$"
  "ABBBBC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2860: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2860"
  "^abc$"
  "ABCC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2863: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2863"
  "^abc"
  "ABCC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2868: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2868"
  "abc$"
  "AABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2871: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2871"
  "^"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; testinput1/2874: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2874"
  "$"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; testinput1/2877: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2877"
  "a.c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2878: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2878"
  "a.c"
  "AXC"
  '(:ignore-case t :single-line nil)
  (list "AXC") )

;;;; testinput1/2881: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2881"
  "a.*?c"
  "AXYZC"
  '(:ignore-case t :single-line nil)
  (list "AXYZC") )

;;;; testinput1/2884: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2884"
  "a.*c"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2885: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2885"
  "a.*c"
  "AABC"
  '(:ignore-case t :single-line nil)
  (list "AABC") )

;;;; testinput1/2886: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2886"
  "a.*c"
  "AXYZD"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2889: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2889"
  "a[bc]d"
  "ABD"
  '(:ignore-case t :single-line nil)
  (list "ABD") )

;;;; testinput1/2892: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2892"
  "a[b-d]e"
  "ACE"
  '(:ignore-case t :single-line nil)
  (list "ACE") )

;;;; testinput1/2893: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2893"
  "a[b-d]e"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2894: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2894"
  "a[b-d]e"
  "ABC"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2895: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2895"
  "a[b-d]e"
  "ABD"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2898: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2898"
  "a[b-d]"
  "AAC"
  '(:ignore-case t :single-line nil)
  (list "AC") )

;;;; testinput1/2901: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2901"
  "a[-b]"
  "A-"
  '(:ignore-case t :single-line nil)
  (list "A-") )

;;;; testinput1/2904: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2904"
  "a[b-]"
  "A-"
  '(:ignore-case t :single-line nil)
  (list "A-") )

;;;; testinput1/2907: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2907"
  "a]"
  "A]"
  '(:ignore-case t :single-line nil)
  (list "A]") )

;;;; testinput1/2910: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2910"
  "a[]]b"
  "A]B"
  '(:ignore-case t :single-line nil)
  (list "A]B") )

;;;; testinput1/2913: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2913"
  "a[^bc]d"
  "AED"
  '(:ignore-case t :single-line nil)
  (list "AED") )

;;;; testinput1/2916: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2916"
  "a[^-b]c"
  "ADC"
  '(:ignore-case t :single-line nil)
  (list "ADC") )

;;;; testinput1/2917: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2917"
  "a[^-b]c"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2918: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2918"
  "a[^-b]c"
  "ABD"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2919: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2919"
  "a[^-b]c"
  "A-C"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2922: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2922"
  "a[^]b]c"
  "ADC"
  '(:ignore-case t :single-line nil)
  (list "ADC") )

;;;; testinput1/2925: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2925"
  "ab|cd"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; testinput1/2926: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2926"
  "ab|cd"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; testinput1/2929: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2929"
  "()ef"
  "DEF"
  '(:ignore-case t :single-line nil)
  (list
    "EF"
    "" ) )

;;;; testinput1/2932: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/2932"
  "$b"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  (list
    "*** Failers"
    "*"
    "*"
    " Failers" ) )

;;;; testinput1/2933: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2933"
  "$b"
  "A]C"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2934: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2934"
  "$b"
  "B"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2937: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2937"
  "a\\(b"
  "A(B"
  '(:ignore-case t :single-line nil)
  (list "A(B") )

;;;; testinput1/2940: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2940"
  "a\\(*b"
  "AB"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; testinput1/2941: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2941"
  "a\\(*b"
  "A((B"
  '(:ignore-case t :single-line nil)
  (list "A((B") )

;;;; testinput1/2944: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/2944"
  "a\\\\b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/2947: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2947"
  "((a))"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A"
    "A" ) )

;;;; testinput1/2950: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/2950"
  "(a)b(c)"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "A"
    "C" ) )

;;;; testinput1/2953: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2953"
  "a+b+c"
  "AABBABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2956: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2956"
  "a{1,}b{1,}c"
  "AABBABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2959: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2959"
  "a.+?c"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2962: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2962"
  "a.*?c"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2965: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2965"
  "a.{0,5}?c"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list "ABC") )

;;;; testinput1/2968: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2968"
  "(a+|b)*"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; testinput1/2971: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2971"
  "(a+|b){0,}"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; testinput1/2974: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2974"
  "(a+|b)+"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; testinput1/2977: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2977"
  "(a+|b){1,}"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "AB"
    "B" ) )

;;;; testinput1/2980: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2980"
  "(a+|b)?"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A" ) )

;;;; testinput1/2983: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2983"
  "(a+|b){0,1}"
  "AB"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A" ) )

;;;; testinput1/2986: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2986"
  "(a+|b){0,1}?"
  "AB"
  '(:ignore-case t :single-line nil)
  (list "") )

;;;; testinput1/2989: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/2989"
  "[^ab]*"
  "CDE"
  '(:ignore-case t :single-line nil)
  (list "CDE") )

;;;; testinput1/2997: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/2997"
  "([abc])*d"
  "ABBBCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABBBCD"
    "C" ) )

;;;; testinput1/3000: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3000"
  "([abc])*bcd"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "A" ) )

;;;; testinput1/3003: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3003"
  "a|b|c|d|e"
  "E"
  '(:ignore-case t :single-line nil)
  (list "E") )

;;;; testinput1/3006: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3006"
  "(a|b|c|d|e)f"
  "EF"
  '(:ignore-case t :single-line nil)
  (list
    "EF"
    "E" ) )

;;;; testinput1/3009: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3009"
  "abcd*efg"
  "ABCDEFG"
  '(:ignore-case t :single-line nil)
  (list "ABCDEFG") )

;;;; testinput1/3012: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3012"
  "ab*"
  "XABYABBBZ"
  '(:ignore-case t :single-line nil)
  (list "AB") )

;;;; testinput1/3013: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3013"
  "ab*"
  "XAYABBBZ"
  '(:ignore-case t :single-line nil)
  (list "A") )

;;;; testinput1/3016: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3016"
  "(ab|cd)e"
  "ABCDE"
  '(:ignore-case t :single-line nil)
  (list
    "CDE"
    "CD" ) )

;;;; testinput1/3019: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3019"
  "[abhgefdc]ij"
  "HIJ"
  '(:ignore-case t :single-line nil)
  (list "HIJ") )

;;;; testinput1/3022: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3022"
  "^(ab|cd)e"
  "ABCDE"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3025: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3025"
  "(abc|)ef"
  "ABCDEF"
  '(:ignore-case t :single-line nil)
  (list
    "EF"
    "" ) )

;;;; testinput1/3028: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3028"
  "(a|b)c*d"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "BCD"
    "B" ) )

;;;; testinput1/3031: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3031"
  "(ab|ab*)bc"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "A" ) )

;;;; testinput1/3034: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3034"
  "a([bc]*)c*"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "BC" ) )

;;;; testinput1/3037: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3037"
  "a([bc]*)(c*d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "BC"
    "D" ) )

;;;; testinput1/3040: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3040"
  "a([bc]+)(c*d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "BC"
    "D" ) )

;;;; testinput1/3043: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3043"
  "a([bc]*)(c+d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "B"
    "CD" ) )

;;;; testinput1/3046: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3046"
  "a[bcd]*dcdcde"
  "ADCDCDE"
  '(:ignore-case t :single-line nil)
  (list "ADCDCDE") )

;;;; testinput1/3051: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3051"
  "(ab|a)b*c"
  "ABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABC"
    "AB" ) )

;;;; testinput1/3054: 
;;;
;;;    Matched with 4 captures.
;
(test-case
  "pcre-1/3054"
  "((a)(b)c)(d)"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "ABC"
    "A"
    "B"
    "D" ) )

;;;; testinput1/3057: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3057"
  "[a-zA-Z_][a-zA-Z0-9_]*"
  "ALPHA"
  '(:ignore-case t :single-line nil)
  (list "ALPHA") )

;;;; testinput1/3060: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3060"
  "^a(bc+|b[eh])g|.h$"
  "ABH"
  '(:ignore-case t :single-line nil)
  (list "BH") )

;;;; testinput1/3063: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3063"
  "(bc+d$|ef*g.|h?i(j|k))"
  "EFFGZ"
  '(:ignore-case t :single-line nil)
  (list
    "EFFGZ"
    "EFFGZ" ) )

;;;; testinput1/3064: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3064"
  "(bc+d$|ef*g.|h?i(j|k))"
  "IJ"
  '(:ignore-case t :single-line nil)
  (list
    "IJ"
    "IJ"
    "J" ) )

;;;; testinput1/3065: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3065"
  "(bc+d$|ef*g.|h?i(j|k))"
  "REFFGZ"
  '(:ignore-case t :single-line nil)
  (list
    "EFFGZ"
    "EFFGZ" ) )

;;;; testinput1/3066: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3066"
  "(bc+d$|ef*g.|h?i(j|k))"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3067: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3067"
  "(bc+d$|ef*g.|h?i(j|k))"
  "ADCDCDE"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3068: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3068"
  "(bc+d$|ef*g.|h?i(j|k))"
  "EFFG"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3069: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3069"
  "(bc+d$|ef*g.|h?i(j|k))"
  "BCDD"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3072: 
;;;
;;;    Matched with 10 captures.
;
(test-case
  "pcre-1/3072"
  "((((((((((a))))))))))"
  "A"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; testinput1/3075: 
;;;
;;;    Matched with 10 captures.
;
(test-case
  "pcre-1/3075"
  "((((((((((a))))))))))\\10"
  "AA"
  '(:ignore-case t :single-line nil)
  (list
    "AA"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; testinput1/3078: 
;;;
;;;    Matched with 9 captures.
;
(test-case
  "pcre-1/3078"
  "(((((((((a)))))))))"
  "A"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A"
    "A" ) )

;;;; testinput1/3081: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3081"
  "(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))"
  "A"
  '(:ignore-case t :single-line nil)
  (list
    "A"
    "A" ) )

;;;; testinput1/3084: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3084"
  "(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))"
  "C"
  '(:ignore-case t :single-line nil)
  (list
    "C"
    "C" ) )

;;;; testinput1/3087: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3087"
  "multiple words of text"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3088: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3088"
  "multiple words of text"
  "AA"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3089: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3089"
  "multiple words of text"
  "UH-UH"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3092: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3092"
  "multiple words"
  "MULTIPLE WORDS, YEAH"
  '(:ignore-case t :single-line nil)
  (list "MULTIPLE WORDS") )

;;;; testinput1/3095: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3095"
  "(.*)c(.*)"
  "ABCDE"
  '(:ignore-case t :single-line nil)
  (list
    "ABCDE"
    "AB"
    "DE" ) )

;;;; testinput1/3098: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3098"
  "\\((.*), (.*)\\)"
  "(A, B)"
  '(:ignore-case t :single-line nil)
  (list
    "(A, B)"
    "A"
    "B" ) )

;;;; testinput1/3103: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3103"
  "abcd"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list "ABCD") )

;;;; testinput1/3106: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3106"
  "a(bc)d"
  "ABCD"
  '(:ignore-case t :single-line nil)
  (list
    "ABCD"
    "BC" ) )

;;;; testinput1/3109: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3109"
  "a[-]?c"
  "AC"
  '(:ignore-case t :single-line nil)
  (list "AC") )

;;;; testinput1/3112: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3112"
  "(abc)\\1"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABCABC"
    "ABC" ) )

;;;; testinput1/3115: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3115"
  "([a-c]*)\\1"
  "ABCABC"
  '(:ignore-case t :single-line nil)
  (list
    "ABCABC"
    "ABC" ) )

;;;; testinput1/3118: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3118"
  "a(?!b)."
  "abad"
  '(:single-line nil)
  (list "ad") )

;;;; testinput1/3121: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3121"
  "a(?=d)."
  "abad"
  '(:single-line nil)
  (list "ad") )

;;;; testinput1/3124: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3124"
  "a(?=c|d)."
  "abad"
  '(:single-line nil)
  (list "ad") )

;;;; testinput1/3127: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3127"
  "a(?:b|c|d)(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "e" ) )

;;;; testinput1/3130: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3130"
  "a(?:b|c|d)*(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "e" ) )

;;;; testinput1/3133: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3133"
  "a(?:b|c|d)+?(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "e" ) )

;;;; testinput1/3134: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3134"
  "a(?:b|c|d)+?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acd"
    "d" ) )

;;;; testinput1/3137: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3137"
  "a(?:b|c|d)+(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput1/3140: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3140"
  "a(?:b|c|d){2}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdb"
    "b" ) )

;;;; testinput1/3143: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3143"
  "a(?:b|c|d){4,5}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdb"
    "b" ) )

;;;; testinput1/3146: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3146"
  "a(?:b|c|d){4,5}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcd"
    "d" ) )

;;;; testinput1/3149: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/3149"
  "((foo)|(bar))*"
  "foobar"
  '(:single-line nil)
  (list
    "foobar"
    "bar"
    "foo"
    "bar" ) )

;;;; testinput1/3152: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3152"
  "a(?:b|c|d){6,7}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput1/3155: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3155"
  "a(?:b|c|d){6,7}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput1/3158: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3158"
  "a(?:b|c|d){5,6}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput1/3161: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3161"
  "a(?:b|c|d){5,6}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdb"
    "b" ) )

;;;; testinput1/3164: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3164"
  "a(?:b|c|d){5,7}(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdbe"
    "e" ) )

;;;; testinput1/3167: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3167"
  "a(?:b|c|d){5,7}?(.)"
  "acdbcdbe"
  '(:single-line nil)
  (list
    "acdbcdb"
    "b" ) )

;;;; testinput1/3170: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3170"
  "a(?:b|(c|e){1,2}?|d)+?(.)"
  "ace"
  '(:single-line nil)
  (list
    "ace"
    "c"
    "e" ) )

;;;; testinput1/3173: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3173"
  "^(.+)?B"
  "AB"
  '(:single-line nil)
  (list
    "AB"
    "A" ) )

;;;; testinput1/3176: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3176"
  "^([^a-z])|(\\^)$"
  "."
  '(:single-line nil)
  (list
    "."
    "." ) )

;;;; testinput1/3179: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3179"
  "^[<>]&"
  "<&OUT"
  '(:single-line nil)
  (list "<&") )

;;;; testinput1/3182: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3182"
  "^(a\\1?){4}$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "aaaa" ) )

;;;; testinput1/3183: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3183"
  "^(a\\1?){4}$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3184: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3184"
  "^(a\\1?){4}$"
  "AB"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3185: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3185"
  "^(a\\1?){4}$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3186: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3186"
  "^(a\\1?){4}$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3189: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3189"
  "^(a(?(1)\\1)){4}$"
  "aaaaaaaaaa"
  '(:single-line nil)
  (list
    "aaaaaaaaaa"
    "aaaa" ) )

;;;; testinput1/3190: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3190"
  "^(a(?(1)\\1)){4}$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3191: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3191"
  "^(a(?(1)\\1)){4}$"
  "aaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3192: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3192"
  "^(a(?(1)\\1)){4}$"
  "aaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3195: 
;;;
;;;    Matched with 6 captures.
;
(test-case
  "pcre-1/3195"
  "(?:(f)(o)(o)|(b)(a)(r))*"
  "foobar"
  '(:single-line nil)
  (list
    "foobar"
    "f"
    "o"
    "o"
    "b"
    "a"
    "r" ) )

;;;; testinput1/3198: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3198"
  "(?<=a)b"
  "ab"
  '(:single-line nil)
  (list "b") )

;;;; testinput1/3199: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3199"
  "(?<=a)b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3200: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3200"
  "(?<=a)b"
  "cb"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3201: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3201"
  "(?<=a)b"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3204: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3204"
  "(?<!c)b"
  "ab"
  '(:single-line nil)
  (list "b") )

;;;; testinput1/3205: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3205"
  "(?<!c)b"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; testinput1/3206: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3206"
  "(?<!c)b"
  "b"
  '(:single-line nil)
  (list "b") )

;;;; testinput1/3209: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3209"
  "(?:..)*a"
  "aba"
  '(:single-line nil)
  (list "aba") )

;;;; testinput1/3212: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3212"
  "(?:..)*?a"
  "aba"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3215: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3215"
  "^(?:b|a(?=(.)))*\\1"
  "abc"
  '(:single-line nil)
  (list
    "ab"
    "b" ) )

;;;; testinput1/3218: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3218"
  "^(){3,5}"
  "abc"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/3221: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3221"
  "^(a+)*ax"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "a" ) )

;;;; testinput1/3224: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3224"
  "^((a|b)+)*ax"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "a"
    "a" ) )

;;;; testinput1/3227: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3227"
  "^((a|bc)+)*ax"
  "aax"
  '(:single-line nil)
  (list
    "aax"
    "a"
    "a" ) )

;;;; testinput1/3230: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3230"
  "(a|x)*ab"
  "cab"
  '(:single-line nil)
  (list
    "ab"
    nil ) )

;;;; testinput1/3233: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3233"
  "(a)*ab"
  "cab"
  '(:single-line nil)
  (list
    "ab"
    nil ) )

;;;; testinput1/3236: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3236"
  "(?:(?i)a)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput1/3239: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3239"
  "((?i)a)b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput1/3242: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3242"
  "(?:(?i)a)b"
  "Ab"
  '(:single-line nil)
  (list "Ab") )

;;;; testinput1/3245: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3245"
  "((?i)a)b"
  "Ab"
  '(:single-line nil)
  (list
    "Ab"
    "A" ) )

;;;; testinput1/3248: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3248"
  "(?:(?i)a)b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3249: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3249"
  "(?:(?i)a)b"
  "cb"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3250: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3250"
  "(?:(?i)a)b"
  "aB"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3255: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3255"
  "(?i:a)b"
  "ab"
  '(:single-line nil)
  (list "ab") )

;;;; testinput1/3258: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3258"
  "((?i:a))b"
  "ab"
  '(:single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput1/3261: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3261"
  "(?i:a)b"
  "Ab"
  '(:single-line nil)
  (list "Ab") )

;;;; testinput1/3264: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3264"
  "((?i:a))b"
  "Ab"
  '(:single-line nil)
  (list
    "Ab"
    "A" ) )

;;;; testinput1/3267: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3267"
  "(?i:a)b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3268: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3268"
  "(?i:a)b"
  "aB"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3269: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3269"
  "(?i:a)b"
  "aB"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3274: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3274"
  "(?:(?-i)a)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list "ab") )

;;;; testinput1/3277: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3277"
  "((?-i)a)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput1/3280: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3280"
  "(?:(?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput1/3283: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3283"
  "((?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; testinput1/3286: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3286"
  "(?:(?-i)a)b"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3287: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3287"
  "(?:(?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput1/3288: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3288"
  "(?:(?-i)a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3293: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3293"
  "(?:(?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput1/3296: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3296"
  "((?-i)a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; testinput1/3299: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3299"
  "(?:(?-i)a)b"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3300: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3300"
  "(?:(?-i)a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3301: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3301"
  "(?:(?-i)a)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3306: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3306"
  "(?-i:a)b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list "ab") )

;;;; testinput1/3309: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3309"
  "((?-i:a))b"
  "ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab"
    "a" ) )

;;;; testinput1/3312: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3312"
  "(?-i:a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput1/3315: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3315"
  "((?-i:a))b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; testinput1/3318: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3318"
  "(?-i:a)b"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3319: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3319"
  "(?-i:a)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3320: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3320"
  "(?-i:a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3325: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3325"
  "(?-i:a)b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list "aB") )

;;;; testinput1/3328: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3328"
  "((?-i:a))b"
  "aB"
  '(:ignore-case t :single-line nil)
  (list
    "aB"
    "a" ) )

;;;; testinput1/3331: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3331"
  "(?-i:a)b"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3332: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3332"
  "(?-i:a)b"
  "Ab"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3333: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3333"
  "(?-i:a)b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3338: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3338"
  "((?-i:a.))b"
  "*** Failers"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3339: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3339"
  "((?-i:a.))b"
  "AB"
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3340: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3340"
  "((?-i:a.))b"
  (backslash "a\\nB")
  '(:ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3343: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3343"
  "((?s-i:a.))b"
  (backslash "a\\nB")
  '(:ignore-case t :single-line nil)
  (list
    (backslash "a\\nB")
    "a
" ) )

;;;; testinput1/3346: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3346"
  "(?:c|d)(?:)(?:a(?:)(?:b)(?:b(?:))(?:b(?:)(?:b)))"
  "cabbbb"
  '(:single-line nil)
  (list "cabbbb") )

;;;; testinput1/3349: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3349"
  "(?:c|d)(?:)(?:aaaaaaaa(?:)(?:bbbbbbbb)(?:bbbbbbbb(?:))(?:bbbbbbbb(?:)(?:bbbbbbbb)))"
  "caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
  '(:single-line nil)
  (list "caaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb") )

;;;; testinput1/3352: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3352"
  "(ab)\\d\\1"
  "Ab4ab"
  '(:ignore-case t :single-line nil)
  (list
    "Ab4ab"
    "Ab" ) )

;;;; testinput1/3353: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3353"
  "(ab)\\d\\1"
  "ab4Ab"
  '(:ignore-case t :single-line nil)
  (list
    "ab4Ab"
    "ab" ) )

;;;; testinput1/3356: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3356"
  "foo\\w*\\d{4}baz"
  "foobar1234baz"
  '(:single-line nil)
  (list "foobar1234baz") )

;;;; testinput1/3359: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3359"
  "x(~~)*(?:(?:F)?)?"
  "x~~"
  '(:single-line nil)
  (list
    "x~~"
    "~~" ) )

;;;; testinput1/3362: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3362"
  "^a(?#xxx){3}c"
  "aaac"
  '(:single-line nil)
  (list "aaac") )

;;;; testinput1/3365: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3365"
  "^a (?#xxx) (?#yyy) {3}c"
  "aaac"
  '(:extended-syntax t :single-line nil)
  (list "aaac") )

;;;; testinput1/3368: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3368"
  "(?<![cd])b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3369: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3369"
  "(?<![cd])b"
  (backslash "B\\nB")
  '(:single-line nil)
  nil
 )

;;;; testinput1/3370: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3370"
  "(?<![cd])b"
  "dbcb"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3373: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3373"
  "(?<![cd])[ab]"
  "dbaacb"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3378: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3378"
  "(?<!(c|d))[ab]"
  "dbaacb"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3381: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3381"
  "(?<!cd)[ab]"
  "cdaccb"
  '(:single-line nil)
  (list "b") )

;;;; testinput1/3384: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3384"
  "^(?:a?b?)*$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3385: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3385"
  "^(?:a?b?)*$"
  "dbcb"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3386: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3386"
  "^(?:a?b?)*$"
  "a--"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3389: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/3389"
  "((?s)^a(.))((?m)^b$)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "a\\nb")
    "a
"
    "
"
    "b" ) )

;;;; testinput1/3392: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3392"
  "((?m)^b$)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; testinput1/3395: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3395"
  "(?m)^b"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list "b") )

;;;; testinput1/3398: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3398"
  "(?m)^(b)"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; testinput1/3401: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3401"
  "((?m)^b)"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; testinput1/3404: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3404"
  "\\n((?m)^b)"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list
    (backslash "\\nb")
    "b" ) )

;;;; testinput1/3407: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3407"
  "((?s).)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "\\nc")
    "
" ) )

;;;; testinput1/3408: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3408"
  "((?s).)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "\\nc")
    "
" ) )

;;;; testinput1/3411: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3411"
  "((?s)b.)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "b\\nc")
    "b
" ) )

;;;; testinput1/3412: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3412"
  "((?s)b.)c(?!.)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    (backslash "b\\nc")
    "b
" ) )

;;;; testinput1/3417: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3417"
  "()^b"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3418: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3418"
  "()^b"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  nil
 )

;;;; testinput1/3419: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3419"
  "()^b"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  nil
 )

;;;; testinput1/3422: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3422"
  "((?m)^b)"
  (backslash "a\\nb\\nc\\n")
  '(:single-line nil)
  (list
    "b"
    "b" ) )

;;;; testinput1/3427: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3427"
  "(?(1)b|a)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3430: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3430"
  "(x)?(?(1)a|b)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3431: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3431"
  "(x)?(?(1)a|b)"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3432: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3432"
  "(x)?(?(1)a|b)"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3435: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3435"
  "(x)?(?(1)b|a)"
  "a"
  '(:single-line nil)
  (list
    "a"
    nil ) )

;;;; testinput1/3438: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3438"
  "()?(?(1)b|a)"
  "a"
  '(:single-line nil)
  (list
    "a"
    nil ) )

;;;; testinput1/3443: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3443"
  "()?(?(1)a|b)"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput1/3446: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3446"
  "^(\\()?blah(?(1)(\\)))$"
  "(blah)"
  '(:single-line nil)
  (list
    "(blah)"
    "("
    ")" ) )

;;;; testinput1/3447: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3447"
  "^(\\()?blah(?(1)(\\)))$"
  "blah"
  '(:single-line nil)
  (list
    "blah"
    nil ) )

;;;; testinput1/3448: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3448"
  "^(\\()?blah(?(1)(\\)))$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3449: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3449"
  "^(\\()?blah(?(1)(\\)))$"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3450: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3450"
  "^(\\()?blah(?(1)(\\)))$"
  "blah)"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3451: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3451"
  "^(\\()?blah(?(1)(\\)))$"
  "(blah"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3454: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3454"
  "^(\\(+)?blah(?(1)(\\)))$"
  "(blah)"
  '(:single-line nil)
  (list
    "(blah)"
    "("
    ")" ) )

;;;; testinput1/3455: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3455"
  "^(\\(+)?blah(?(1)(\\)))$"
  "blah"
  '(:single-line nil)
  (list "blah") )

;;;; testinput1/3456: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3456"
  "^(\\(+)?blah(?(1)(\\)))$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3457: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3457"
  "^(\\(+)?blah(?(1)(\\)))$"
  "blah)"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3458: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3458"
  "^(\\(+)?blah(?(1)(\\)))$"
  "(blah"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3463: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3463"
  "(?(?!a)b|a)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3466: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3466"
  "(?(?=a)b|a)"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3467: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3467"
  "(?(?=a)b|a)"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3468: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3468"
  "(?(?=a)b|a)"
  "a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3471: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3471"
  "(?(?=a)a|b)"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3474: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3474"
  "(?=(a+?))(\\1ab)"
  "aaab"
  '(:single-line nil)
  (list
    "aab"
    "a"
    "aab" ) )

;;;; testinput1/3479: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3479"
  "(\\w+:)+"
  "one:"
  '(:single-line nil)
  (list
    "one:"
    "one:" ) )

;;;; testinput1/3482: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3482"
  "$(?<=^(a))"
  "a"
  '(:single-line nil)
  (list
    ""
    "a" ) )

;;;; testinput1/3485: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3485"
  "(?=(a+?))(\\1ab)"
  "aaab"
  '(:single-line nil)
  (list
    "aab"
    "a"
    "aab" ) )

;;;; testinput1/3488: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3488"
  "^(?=(a+?))\\1ab"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3489: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3489"
  "^(?=(a+?))\\1ab"
  "aaab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3490: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3490"
  "^(?=(a+?))\\1ab"
  "aaab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3493: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3493"
  "([\\w:]+::)?(\\w+)$"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    nil
    "abcd" ) )

;;;; testinput1/3494: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3494"
  "([\\w:]+::)?(\\w+)$"
  "xy:z:::abcd"
  '(:single-line nil)
  (list
    "xy:z:::abcd"
    "xy:z:::"
    "abcd" ) )

;;;; testinput1/3497: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3497"
  "^[^bcd]*(c+)"
  "aexycd"
  '(:single-line nil)
  (list
    "aexyc"
    "c" ) )

;;;; testinput1/3500: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3500"
  "(a*)b+"
  "caab"
  '(:single-line nil)
  (list
    "aab"
    "aa" ) )

;;;; testinput1/3503: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3503"
  "([\\w:]+::)?(\\w+)$"
  "abcd"
  '(:single-line nil)
  (list
    "abcd"
    nil
    "abcd" ) )

;;;; testinput1/3504: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3504"
  "([\\w:]+::)?(\\w+)$"
  "xy:z:::abcd"
  '(:single-line nil)
  (list
    "xy:z:::abcd"
    "xy:z:::"
    "abcd" ) )

;;;; testinput1/3505: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3505"
  "([\\w:]+::)?(\\w+)$"
  "*** Failers"
  '(:single-line nil)
  (list
    "Failers"
    nil
    "Failers" ) )

;;;; testinput1/3506: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3506"
  "([\\w:]+::)?(\\w+)$"
  "abcd:"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3507: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3507"
  "([\\w:]+::)?(\\w+)$"
  "abcd:"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3510: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3510"
  "^[^bcd]*(c+)"
  "aexycd"
  '(:single-line nil)
  (list
    "aexyc"
    "c" ) )

;;;; testinput1/3515: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3515"
  "(?>a+)b"
  "aaab"
  '(:single-line nil)
  (list "aaab") )

;;;; testinput1/3518: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3518"
  "([[:]+)"
  "a:[b]:"
  '(:single-line nil)
  (list
    ":["
    ":[" ) )

;;;; testinput1/3521: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3521"
  "([[=]+)"
  "a=[b]="
  '(:single-line nil)
  (list
    "=["
    "=[" ) )

;;;; testinput1/3524: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3524"
  "([[.]+)"
  "a.[b]."
  '(:single-line nil)
  (list
    ".["
    ".[" ) )

;;;; testinput1/3527: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3527"
  "((?>a+)b)"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaab" ) )

;;;; testinput1/3530: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3530"
  "(?>(a+))b"
  "aaab"
  '(:single-line nil)
  (list
    "aaab"
    "aaa" ) )

;;;; testinput1/3533: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3533"
  "((?>[^()]+)|\\([^()]*\\))+"
  "((abc(ade)ufh()()x"
  '(:single-line nil)
  (list
    "abc(ade)ufh()()x"
    "x" ) )

;;;; testinput1/3536: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3536"
  "a\\Z"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3537: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3537"
  "a\\Z"
  "aaab"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3538: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3538"
  "a\\Z"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  nil
 )

;;;; testinput1/3541: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3541"
  "b\\Z"
  (backslash "a\\nb\\n")
  '(:single-line nil)
  (list "b") )

;;;; testinput1/3546: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3546"
  "b\\Z"
  (backslash "a\\nb")
  '(:single-line nil)
  (list "b") )

;;;; testinput1/3549: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3549"
  "b\\z"
  (backslash "a\\nb")
  '(:single-line nil)
  (list "b") )

;;;; testinput1/3550: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3550"
  "b\\z"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3553: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3553"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a"
  '(:single-line nil)
  (list
    "a"
    "" ) )

;;;; testinput1/3554: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3554"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "abc"
  '(:single-line nil)
  (list
    "abc"
    "" ) )

;;;; testinput1/3555: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3555"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a-b"
  '(:single-line nil)
  (list
    "a-b"
    "" ) )

;;;; testinput1/3556: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3556"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "0-9"
  '(:single-line nil)
  (list
    "0-9"
    "" ) )

;;;; testinput1/3557: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3557"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a.b"
  '(:single-line nil)
  (list
    "a.b"
    "" ) )

;;;; testinput1/3558: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3558"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "5.6.7"
  '(:single-line nil)
  (list
    "5.6.7"
    "" ) )

;;;; testinput1/3559: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3559"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox"
  '(:single-line nil)
  (list
    "the.quick.brown.fox"
    "" ) )

;;;; testinput1/3560: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3560"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a100.b200.300c"
  '(:single-line nil)
  (list
    "a100.b200.300c"
    "" ) )

;;;; testinput1/3561: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3561"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "12-ab.1245"
  '(:single-line nil)
  (list
    "12-ab.1245"
    "" ) )

;;;; testinput1/3562: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3562"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3563: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3563"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  ""
  '(:single-line nil)
  nil
 )

;;;; testinput1/3564: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3564"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  ".a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3565: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3565"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "-a"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3566: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3566"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a-"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3567: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3567"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a."
  '(:single-line nil)
  nil
 )

;;;; testinput1/3568: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3568"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a_b"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3569: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3569"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a.-"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3570: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3570"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "a.."
  '(:single-line nil)
  nil
 )

;;;; testinput1/3571: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3571"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "ab..bc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3572: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3572"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox-"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3573: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3573"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox."
  '(:single-line nil)
  nil
 )

;;;; testinput1/3574: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3574"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox_"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3575: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3575"
  "^(?>(?(1)\\.|())[^\\W_](?>[a-z0-9-]*[^\\W_])?)+$"
  "the.quick.brown.fox+"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3578: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3578"
  "(?>.*)(?<=(abcd|wxyz))"
  "alphabetabcd"
  '(:single-line nil)
  (list
    "alphabetabcd"
    "abcd" ) )

;;;; testinput1/3579: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3579"
  "(?>.*)(?<=(abcd|wxyz))"
  "endingwxyz"
  '(:single-line nil)
  (list
    "endingwxyz"
    "wxyz" ) )

;;;; testinput1/3580: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3580"
  "(?>.*)(?<=(abcd|wxyz))"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3581: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3581"
  "(?>.*)(?<=(abcd|wxyz))"
  "a rather long string that doesn't end with one of them"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3584: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3584"
  "word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark otherword"
  '(:single-line nil)
  (list "word cat dog elephant mussel cow horse canary baboon snake shark otherword") )

;;;; testinput1/3585: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3585"
  "word (?>(?:(?!otherword)[a-zA-Z0-9]+ ){0,30})otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3588: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3588"
  "word (?>[a-zA-Z0-9]+ ){0,30}otherword"
  "word cat dog elephant mussel cow horse canary baboon snake shark the quick brown fox and the lazy dog and several other words getting close to thirty by now I hope"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3591: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3591"
  "(?<=\\d{3}(?!999))foo"
  "999foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/3592: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3592"
  "(?<=\\d{3}(?!999))foo"
  "123999foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/3593: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3593"
  "(?<=\\d{3}(?!999))foo"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3594: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3594"
  "(?<=\\d{3}(?!999))foo"
  "123abcfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3597: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3597"
  "(?<=(?!...999)\\d{3})foo"
  "999foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/3598: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3598"
  "(?<=(?!...999)\\d{3})foo"
  "123999foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/3599: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3599"
  "(?<=(?!...999)\\d{3})foo"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3600: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3600"
  "(?<=(?!...999)\\d{3})foo"
  "123abcfoo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3603: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3603"
  "(?<=\\d{3}(?!999)...)foo"
  "123abcfoo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/3604: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3604"
  "(?<=\\d{3}(?!999)...)foo"
  "123456foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/3605: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3605"
  "(?<=\\d{3}(?!999)...)foo"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3606: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3606"
  "(?<=\\d{3}(?!999)...)foo"
  "123999foo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3609: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3609"
  "(?<=\\d{3}...)(?<!999)foo"
  "123abcfoo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/3610: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3610"
  "(?<=\\d{3}...)(?<!999)foo"
  "123456foo"
  '(:single-line nil)
  (list "foo") )

;;;; testinput1/3611: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3611"
  "(?<=\\d{3}...)(?<!999)foo"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3612: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3612"
  "(?<=\\d{3}...)(?<!999)foo"
  "123999foo"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3619: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/3619"
  (backslash "<a[\\s]+href[\\s]*=[\\s]*          # find <a href=\\n ([\"'])?                       # find single or double quote\\n (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=abcd xyz"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=abcd"
    nil
    nil
    "abcd" ) )

;;;; testinput1/3620: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3620"
  (backslash "<a[\\s]+href[\\s]*=[\\s]*          # find <a href=\\n ([\"'])?                       # find single or double quote\\n (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=\"abcd xyz pqr\" cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=\"abcd xyz pqr\""
    "\""
    "abcd xyz pqr" ) )

;;;; testinput1/3621: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3621"
  (backslash "<a[\\s]+href[\\s]*=[\\s]*          # find <a href=\\n ([\"'])?                       # find single or double quote\\n (?(1) (.*?)\\1 | ([^\\s]+))       # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href='abcd xyz pqr' cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href='abcd xyz pqr'"
    "'"
    "abcd xyz pqr" ) )

;;;; testinput1/3628: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/3628"
  (backslash "<a\\s+href\\s*=\\s*                # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=abcd xyz"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=abcd"
    nil
    nil
    "abcd" ) )

;;;; testinput1/3629: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3629"
  (backslash "<a\\s+href\\s*=\\s*                # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=\"abcd xyz pqr\" cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=\"abcd xyz pqr\""
    "\""
    "abcd xyz pqr" ) )

;;;; testinput1/3630: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3630"
  (backslash "<a\\s+href\\s*=\\s*                # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href       =       'abcd xyz pqr' cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href       =       'abcd xyz pqr'"
    "'"
    "abcd xyz pqr" ) )

;;;; testinput1/3637: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/3637"
  (backslash "<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=abcd xyz"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=abcd"
    nil
    nil
    "abcd" ) )

;;;; testinput1/3638: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3638"
  (backslash "<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href=\"abcd xyz pqr\" cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href=\"abcd xyz pqr\""
    "\""
    "abcd xyz pqr" ) )

;;;; testinput1/3639: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3639"
  (backslash "<a\\s+href(?>\\s*)=(?>\\s*)        # find <a href=\\n ([\"'])?                         # find single or double quote\\n (?(1) (.*?)\\1 | (\\S+))          # if quote found, match up to next matching\\n                                 # quote, otherwise match up to next space\\n")
  "<a href       =       'abcd xyz pqr' cats"
  '(:ignore-case t :single-line t :extended-syntax t)
  (list
    "<a href       =       'abcd xyz pqr'"
    "'"
    "abcd xyz pqr" ) )

;;;; testinput1/3642: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3642"
  "((Z)+|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    "ZA"
    "A"
    "Z" ) )

;;;; testinput1/3645: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3645"
  "(Z()|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    "ZA"
    "A"
    "" ) )

;;;; testinput1/3648: 
;;;
;;;    Matched with 3 captures.
;
(test-case
  "pcre-1/3648"
  "(Z(())|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    "ZA"
    "A"
    ""
    "" ) )

;;;; testinput1/3651: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3651"
  "((?>Z)+|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    "ZA"
    "A" ) )

;;;; testinput1/3654: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3654"
  "((?>)+|A)*"
  "ZABCDEFG"
  '(:single-line nil)
  (list
    ""
    "" ) )

;;;; testinput1/3657: 
;;;
;;;    
;
(test-case/g
  "pcre-1/3657"
  "a*"
  "abbab"
  '(:single-line nil)
  (list "a"
        ""
        ""
        "a"
        ""
        "" )
    "" )

;;;; testinput1/3660: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3660"
  "^[a-\\d]"
  "abcde"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3661: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3661"
  "^[a-\\d]"
  "-things"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/3662: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3662"
  "^[a-\\d]"
  "0digit"
  '(:single-line nil)
  (list "0") )

;;;; testinput1/3663: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3663"
  "^[a-\\d]"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3664: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3664"
  "^[a-\\d]"
  "bcdef"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3667: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3667"
  "^[\\d-a]"
  "abcde"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3668: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3668"
  "^[\\d-a]"
  "-things"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/3669: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3669"
  "^[\\d-a]"
  "0digit"
  '(:single-line nil)
  (list "0") )

;;;; testinput1/3670: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3670"
  "^[\\d-a]"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3671: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3671"
  "^[\\d-a]"
  "bcdef"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3674: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3674"
  "[[:space:]]+"
  (backslash "> \\t\\n\\u000C\\u000D\\u000B<")
  '(:single-line nil)
  (list (backslash " \\t\\n\\u000C\\u000D\\u000B")) )

;;;; testinput1/3677: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3677"
  "[[:blank:]]+"
  (backslash "> \\t\\n\\u000C\\u000D\\u000B<")
  '(:single-line nil)
  (list (backslash " \\t")) )

;;;; testinput1/3680: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3680"
  "[\\s]+"
  (backslash "> \\t\\n\\u000C\\u000D\\u000B<")
  '(:single-line nil)
  (list (backslash " \\t\\n\\u000C\\u000D")) )

;;;; testinput1/3683: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3683"
  "\\s+"
  (backslash "> \\t\\n\\u000C\\u000D\\u000B<")
  '(:single-line nil)
  (list (backslash " \\t\\n\\u000C\\u000D")) )

;;;; testinput1/3686: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3686"
  (backslash "a\\u000Bb")
  "ab"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/3689: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3689"
  "(?!\\A)x"
  (backslash "a\\nxb\\n")
  '(:multiple-lines t :single-line nil)
  (list "x") )

;;;; testinput1/3692: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3692"
  "(?!^)x"
  (backslash "a\\nxb\\n")
  '(:multiple-lines t :single-line nil)
  nil
 )

;;;; testinput1/3695: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3695"
  "abc\\Qabc\\Eabc"
  "abcabcabc"
  '(:single-line nil)
  (list "abcabcabc") )

;;;; testinput1/3698: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3698"
  "abc\\Q(*+|\\Eabc"
  "abc(*+|abc"
  '(:single-line nil)
  (list "abc(*+|abc") )

;;;; testinput1/3701: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3701"
  "   abc\\Q abc\\Eabc"
  "abc abcabc"
  '(:extended-syntax t :single-line nil)
  (list "abc abcabc") )

;;;; testinput1/3702: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3702"
  "   abc\\Q abc\\Eabc"
  "*** Failers"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/3703: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3703"
  "   abc\\Q abc\\Eabc"
  "abcabcabc"
  '(:extended-syntax t :single-line nil)
  nil
 )

;;;; testinput1/3708: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3708"
  (backslash "abc#comment\\n    \\Q#not comment\\n    literal\\E")
  (backslash "abc#not comment\\n    literal")
  '(:extended-syntax t :single-line nil)
  (list (backslash "abc#not comment\\n    literal")) )

;;;; testinput1/3713: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3713"
  (backslash "abc#comment\\n    \\Q#not comment\\n    literal")
  (backslash "abc#not comment\\n    literal")
  '(:extended-syntax t :single-line nil)
  (list (backslash "abc#not comment\\n    literal")) )

;;;; testinput1/3719: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3719"
  (backslash "abc#comment\\n    \\Q#not comment\\n    literal\\E #more comment\\n    ")
  (backslash "abc#not comment\\n    literal")
  '(:extended-syntax t :single-line nil)
  (list (backslash "abc#not comment\\n    literal")) )

;;;; testinput1/3724: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3724"
  (backslash "abc#comment\\n    \\Q#not comment\\n    literal\\E #more comment")
  (backslash "abc#not comment\\n    literal")
  '(:extended-syntax t :single-line nil)
  (list (backslash "abc#not comment\\n    literal")) )

;;;; testinput1/3727: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3727"
  "\\Qabc\\$xyz\\E"
  "abc\\$xyz"
  '(:single-line nil)
  (list "abc\\$xyz") )

;;;; testinput1/3730: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3730"
  "\\Qabc\\E\\$\\Qxyz\\E"
  "abc$xyz"
  '(:single-line nil)
  (list "abc$xyz") )

;;;; testinput1/3733: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3733"
  "\\Gabc"
  "abc"
  '(:single-line nil)
  (list "abc") )

;;;; testinput1/3734: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3734"
  "\\Gabc"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3735: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3735"
  "\\Gabc"
  "xyzabc"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3738: 
;;;
;;;    
;
(test-case/g
  "pcre-1/3738"
  "\\Gabc."
  "abc1abc2xyzabc3"
  '(:single-line nil)
  (list "abc1"
        "abc2" )
    "" )

;;;; testinput1/3741: 
;;;
;;;    
;
(test-case/g
  "pcre-1/3741"
  "abc."
  "abc1abc2xyzabc3"
  '(:single-line nil)
  (list "abc1"
        "abc2"
        "abc3" )
    "" )

;;;; testinput1/3744: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3744"
  "a(?x: b c )d"
  "XabcdY"
  '(:single-line nil)
  (list "abcd") )

;;;; testinput1/3745: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3745"
  "a(?x: b c )d"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3746: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3746"
  "a(?x: b c )d"
  "Xa b c d Y"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3749: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3749"
  "((?x)x y z | a b c)"
  "XabcY"
  '(:single-line nil)
  (list
    "abc"
    "abc" ) )

;;;; testinput1/3750: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3750"
  "((?x)x y z | a b c)"
  "AxyzB"
  '(:single-line nil)
  (list
    "xyz"
    "xyz" ) )

;;;; testinput1/3753: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3753"
  "(?i)AB(?-i)C"
  "XabCY"
  '(:single-line nil)
  (list "abC") )

;;;; testinput1/3754: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3754"
  "(?i)AB(?-i)C"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3755: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3755"
  "(?i)AB(?-i)C"
  "XabcY"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3758: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3758"
  "((?i)AB(?-i)C|D)E"
  "abCE"
  '(:single-line nil)
  (list
    "abCE"
    "abC" ) )

;;;; testinput1/3759: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3759"
  "((?i)AB(?-i)C|D)E"
  "DE"
  '(:single-line nil)
  (list
    "DE"
    "D" ) )

;;;; testinput1/3760: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3760"
  "((?i)AB(?-i)C|D)E"
  "*** Failers"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3761: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3761"
  "((?i)AB(?-i)C|D)E"
  "abcE"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3762: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3762"
  "((?i)AB(?-i)C|D)E"
  "abCe"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3763: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3763"
  "((?i)AB(?-i)C|D)E"
  "dE"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3764: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3764"
  "((?i)AB(?-i)C|D)E"
  "De"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3767: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3767"
  "(.*)\\d+\\1"
  "abc123abc"
  '(:single-line nil)
  (list
    "abc123abc"
    "abc" ) )

;;;; testinput1/3768: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3768"
  "(.*)\\d+\\1"
  "abc123bc"
  '(:single-line nil)
  (list
    "bc123bc"
    "bc" ) )

;;;; testinput1/3771: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3771"
  "(.*)\\d+\\1"
  "abc123abc"
  '(:single-line t)
  (list
    "abc123abc"
    "abc" ) )

;;;; testinput1/3772: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3772"
  "(.*)\\d+\\1"
  "abc123bc"
  '(:single-line t)
  (list
    "bc123bc"
    "bc" ) )

;;;; testinput1/3775: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3775"
  "((.*))\\d+\\1"
  "abc123abc"
  '(:single-line nil)
  (list
    "abc123abc"
    "abc"
    "abc" ) )

;;;; testinput1/3776: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-1/3776"
  "((.*))\\d+\\1"
  "abc123bc"
  '(:single-line nil)
  (list
    "bc123bc"
    "bc"
    "bc" ) )

;;;; testinput1/3791: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3791"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "a123::a123"
  '(:extended-syntax t :ignore-case t :single-line nil)
  (list
    "a123::a123"
    "" ) )

;;;; testinput1/3792: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3792"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "a123:b342::abcd"
  '(:extended-syntax t :ignore-case t :single-line nil)
  (list
    "a123:b342::abcd"
    "" ) )

;;;; testinput1/3793: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3793"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "a123:b342::324e:abcd"
  '(:extended-syntax t :ignore-case t :single-line nil)
  (list
    "a123:b342::324e:abcd"
    "" ) )

;;;; testinput1/3794: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3794"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "a123:ddde:b342::324e:abcd"
  '(:extended-syntax t :ignore-case t :single-line nil)
  (list
    "a123:ddde:b342::324e:abcd"
    "" ) )

;;;; testinput1/3795: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3795"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "a123:ddde:b342::324e:dcba:abcd"
  '(:extended-syntax t :ignore-case t :single-line nil)
  (list
    "a123:ddde:b342::324e:dcba:abcd"
    "" ) )

;;;; testinput1/3796: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-1/3796"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "a123:ddde:9999:b342::324e:dcba:abcd"
  '(:extended-syntax t :ignore-case t :single-line nil)
  (list
    "a123:ddde:9999:b342::324e:dcba:abcd"
    "" ) )

;;;; testinput1/3797: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3797"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "*** Failers"
  '(:extended-syntax t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3798: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3798"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "1:2:3:4:5:6:7:8"
  '(:extended-syntax t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3799: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3799"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "a123:bce:ddde:9999:b342::324e:dcba:abcd"
  '(:extended-syntax t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3800: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3800"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "a123::9999:b342::324e:dcba:abcd"
  '(:extended-syntax t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3801: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3801"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "abcde:2:3:4:5:6:7:8"
  '(:extended-syntax t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3802: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3802"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "::1"
  '(:extended-syntax t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3803: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3803"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "abcd:fee0:123::"
  '(:extended-syntax t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3804: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3804"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  ":1"
  '(:extended-syntax t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3805: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3805"
  (backslash "^(?!:)                       # colon disallowed at start\\n  (?:                         # start of item\\n    (?: [0-9a-f]{1,4} |       # 1-4 hex digits or\\n    (?(1)0 | () ) )           # if null previously matched, fail; else null\\n    :                         # followed by colon\\n  ){1,7}                      # end item; 1-7 of them required\\n  [0-9a-f]{1,4} $             # final hex number at end of string\\n  (?(1)|.)                    # check that there was an empty component\\n  ")
  "1:"
  '(:extended-syntax t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput1/3808: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3808"
  "[z\\Qa-d]\\E]"
  "z"
  '(:single-line nil)
  (list "z") )

;;;; testinput1/3809: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3809"
  "[z\\Qa-d]\\E]"
  "a"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3810: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3810"
  "[z\\Qa-d]\\E]"
  "-"
  '(:single-line nil)
  (list "-") )

;;;; testinput1/3811: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3811"
  "[z\\Qa-d]\\E]"
  "d"
  '(:single-line nil)
  (list "d") )

;;;; testinput1/3812: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3812"
  "[z\\Qa-d]\\E]"
  "]"
  '(:single-line nil)
  (list "]") )

;;;; testinput1/3813: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3813"
  "[z\\Qa-d]\\E]"
  "*** Failers"
  '(:single-line nil)
  (list "a") )

;;;; testinput1/3814: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3814"
  "[z\\Qa-d]\\E]"
  "b"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3817: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3817"
  "[\\z\\C]"
  "z"
  '(:single-line nil)
  (list "z") )

;;;; testinput1/3818: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3818"
  "[\\z\\C]"
  "C"
  '(:single-line nil)
  (list "C") )

;;;; testinput1/3821: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3821"
  "\\M"
  "M"
  '(:single-line nil)
  (list "M") )

;;;; testinput1/3824: 
;;;
;;;    Not matched
;
(test-case
  "pcre-1/3824"
  "(a+)*b"
  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:single-line nil)
  nil
 )

;;;; testinput1/3827: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3827"
  (backslash "(?i)reg(?:ul(?:[a\\u00E4]|ae)r|ex)")
  "REGular"
  '(:single-line nil)
  (list "REGular") )

;;;; testinput1/3828: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3828"
  (backslash "(?i)reg(?:ul(?:[a\\u00E4]|ae)r|ex)")
  "regulaer"
  '(:single-line nil)
  (list "regulaer") )

;;;; testinput1/3829: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3829"
  (backslash "(?i)reg(?:ul(?:[a\\u00E4]|ae)r|ex)")
  "Regex"
  '(:single-line nil)
  (list "Regex") )

;;;; testinput1/3830: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3830"
  (backslash "(?i)reg(?:ul(?:[a\\u00E4]|ae)r|ex)")
  (backslash "regul\\u00E4r")
  '(:single-line nil)
  (list (backslash "regul\\u00E4r")) )

;;;; testinput1/3833: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3833"
  (backslash "\\u00C5\\u00E6\\u00E5\\u00E4[\\u00E0-\\u00FF\\u00C0-\\u00DF]+")
  (backslash "\\u00C5\\u00E6\\u00E5\\u00E4\\u00E0")
  '(:single-line nil)
  (list (backslash "\\u00C5\\u00E6\\u00E5\\u00E4\\u00E0")) )

;;;; testinput1/3834: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3834"
  (backslash "\\u00C5\\u00E6\\u00E5\\u00E4[\\u00E0-\\u00FF\\u00C0-\\u00DF]+")
  (backslash "\\u00C5\\u00E6\\u00E5\\u00E4\\u00FF")
  '(:single-line nil)
  (list (backslash "\\u00C5\\u00E6\\u00E5\\u00E4\\u00FF")) )

;;;; testinput1/3835: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3835"
  (backslash "\\u00C5\\u00E6\\u00E5\\u00E4[\\u00E0-\\u00FF\\u00C0-\\u00DF]+")
  (backslash "\\u00C5\\u00E6\\u00E5\\u00E4\\u00C0")
  '(:single-line nil)
  (list (backslash "\\u00C5\\u00E6\\u00E5\\u00E4\\u00C0")) )

;;;; testinput1/3836: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3836"
  (backslash "\\u00C5\\u00E6\\u00E5\\u00E4[\\u00E0-\\u00FF\\u00C0-\\u00DF]+")
  (backslash "\\u00C5\\u00E6\\u00E5\\u00E4\\u00DF")
  '(:single-line nil)
  (list (backslash "\\u00C5\\u00E6\\u00E5\\u00E4\\u00DF")) )

;;;; testinput1/3839: 
;;;
;;;    Matched
;
(test-case
  "pcre-1/3839"
  "(?<=Z)X."
  (backslash "\\u0084XAZXB")
  '(:single-line nil)
  (list "XB") )

; EOF
